cache

pkg/common/db/controller/auth.go

@@ -2,6 +2,7 @@ package controller
 
 import (
 	"context"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"

pkg/common/db/controller/black.go

@@ -3,6 +3,8 @@ package controller
 import (
 	"context"
 	"errors"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"gorm.io/gorm"
@@ -15,16 +17,18 @@ type BlackDatabase interface {
 	Delete(ctx context.Context, blacks []*relation.BlackModel) (err error)
 	// FindOwnerBlacks 获取黑名单列表
 	FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*relation.BlackModel, total int64, err error)
+	FindBlackIDs(ctx context.Context, ownerUserID string) (blackIDs []string, err error)
 	// CheckIn 检查user2是否在user1的黑名单列表中(inUser1Blacks==true) 检查user1是否在user2的黑名单列表中(inUser2Blacks==true)
 	CheckIn(ctx context.Context, userID1, userID2 string) (inUser1Blacks bool, inUser2Blacks bool, err error)
 }
 
 type blackDatabase struct {
 	black relation.BlackModelInterface
+	cache cache.BlackCache
 }
 
-func NewBlackDatabase(black relation.BlackModelInterface) BlackDatabase {
-	return &blackDatabase{black}
+func NewBlackDatabase(black relation.BlackModelInterface, cache cache.BlackCache) BlackDatabase {
+	return &blackDatabase{black, cache}
 }
 
 // Create 增加黑名单
@@ -66,3 +70,7 @@ func (b *blackDatabase) CheckIn(ctx context.Context, userID1, userID2 string) (i
 	}
 	return
 }
+
+func (b *blackDatabase) FindBlackIDs(ctx context.Context, ownerUserID string) (blackIDs []string, err error) {
+	return b.cache.GetBlackIDs(ctx, ownerUserID)
+}

pkg/common/db/controller/chatlog.go

@@ -6,7 +6,7 @@ import (
 )
 
 type ChatLogDatabase interface {
-	CreateChatLog(msg pbMsg.MsgDataToMQ) error
+	CreateChatLog(msg *pbMsg.MsgDataToMQ) error
 	GetChatLog(chatLog *relationTb.ChatLogModel, pageNumber, showNumber int32, contentTypes []int32) (int64, []relationTb.ChatLogModel, error)
 }
 
@@ -18,7 +18,7 @@ type chatLogDatabase struct {
 	chatLogModel relationTb.ChatLogModelInterface
 }
 
-func (c *chatLogDatabase) CreateChatLog(msg pbMsg.MsgDataToMQ) error {
+func (c *chatLogDatabase) CreateChatLog(msg *pbMsg.MsgDataToMQ) error {
 	return c.chatLogModel.Create(msg)
 }
 

pkg/common/db/controller/conversation.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"context"
-	"encoding/json"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
@@ -12,10 +11,8 @@ import (
 )
 
 type ConversationDatabase interface {
-	//GetUserIDExistConversation 获取拥有该会话的的用户ID列表
-	GetUserIDExistConversation(ctx context.Context, userIDList []string, conversationID string) ([]string, error)
 	//UpdateUserConversationFiled 更新用户该会话的属性信息
-	UpdateUsersConversationFiled(ctx context.Context, UserIDList []string, conversationID string, args map[string]interface{}) error
+	UpdateUsersConversationFiled(ctx context.Context, userIDs []string, conversationID string, args map[string]interface{}) error
 	//CreateConversation 创建一批新的会话
 	CreateConversation(ctx context.Context, conversations []*relationTb.ConversationModel) error
 	//SyncPeerUserPrivateConversation 同步对端私聊会话内部保证事务操作
@@ -29,7 +26,7 @@ type ConversationDatabase interface {
 	//SetUserConversations 设置用户多个会话属性，如果会话不存在则创建，否则更新,内部保证原子性
 	SetUserConversations(ctx context.Context, ownerUserID string, conversations []*relationTb.ConversationModel) error
 	//SetUsersConversationFiledTx 设置多个用户会话关于某个字段的更新操作，如果会话不存在则创建，否则更新，内部保证事务操作
-	SetUsersConversationFiledTx(ctx context.Context, userIDList []string, conversation *relationTb.ConversationModel, filedMap map[string]interface{}) error
+	SetUsersConversationFiledTx(ctx context.Context, userIDs []string, conversation *relationTb.ConversationModel, filedMap map[string]interface{}) error
 }
 
 func NewConversationDatabase(conversation relationTb.ConversationModelInterface, cache cache.ConversationCache, tx tx.Tx) ConversationDatabase {
@@ -46,22 +43,22 @@ type ConversationDataBase struct {
 	tx             tx.Tx
 }
 
-func (c *ConversationDataBase) SetUsersConversationFiledTx(ctx context.Context, userIDList []string, conversation *relationTb.ConversationModel, filedMap map[string]interface{}) error {
+func (c *ConversationDataBase) SetUsersConversationFiledTx(ctx context.Context, userIDs []string, conversation *relationTb.ConversationModel, filedMap map[string]interface{}) error {
 	return c.tx.Transaction(func(tx any) error {
 		conversationTx := c.conversationDB.NewTx(tx)
-		haveUserID, err := conversationTx.FindUserID(ctx, userIDList, conversation.ConversationID)
+		haveUserIDs, err := conversationTx.FindUserID(ctx, userIDs, conversation.ConversationID)
 		if err != nil {
 			return err
 		}
-		if len(haveUserID) > 0 {
-			err = conversationTx.UpdateByMap(ctx, haveUserID, conversation.ConversationID, filedMap)
+		if len(haveUserIDs) > 0 {
+			err = conversationTx.UpdateByMap(ctx, haveUserIDs, conversation.ConversationID, filedMap)
 			if err != nil {
 				return err
 			}
 		}
-		NotUserID := utils.DifferenceString(haveUserID, userIDList)
+		NotUserIDs := utils.DifferenceString(haveUserIDs, userIDs)
 		var cList []*relationTb.ConversationModel
-		for _, v := range NotUserID {
+		for _, v := range NotUserIDs {
 			temp := new(relationTb.ConversationModel)
 			if err := utils.CopyStructFields(temp, conversation); err != nil {
 				return err
@@ -73,26 +70,17 @@ func (c *ConversationDataBase) SetUsersConversationFiledTx(ctx context.Context,
 		if err != nil {
 			return err
 		}
-		if len(NotUserID) > 0 {
-			err = c.cache.DelUsersConversationIDs(ctx, NotUserID)
-			if err != nil {
-				return err
-			}
-		}
-		err = c.cache.DelUsersConversation(ctx, haveUserID, conversation.ConversationID)
-		if err != nil {
-			return err
-		}
-		return nil
+		// clear cache
+		return c.cache.DelConversationIDs(NotUserIDs).DelUsersConversation(haveUserIDs, conversation.ConversationID).ExecDel(ctx)
 	})
 }
 
-func (c *ConversationDataBase) GetUserIDExistConversation(ctx context.Context, userIDList []string, conversationID string) ([]string, error) {
-	panic("implement me")
-}
-
-func (c *ConversationDataBase) UpdateUsersConversationFiled(ctx context.Context, UserIDList []string, conversationID string, args map[string]interface{}) error {
-	panic("implement me")
+func (c *ConversationDataBase) UpdateUsersConversationFiled(ctx context.Context, userIDs []string, conversationID string, args map[string]interface{}) error {
+	err := c.conversationDB.UpdateByMap(ctx, userIDs, conversationID, args)
+	if err != nil {
+		return err
+	}
+	return c.cache.DelUsersConversation(userIDs, conversationID).ExecDel(ctx)
 }
 
 func (c *ConversationDataBase) CreateConversation(ctx context.Context, conversations []*relationTb.ConversationModel) error {
@@ -100,7 +88,6 @@ func (c *ConversationDataBase) CreateConversation(ctx context.Context, conversat
 		if err := c.conversationDB.NewTx(tx).Create(ctx, conversations); err != nil {
 			return err
 		}
-		// clear cache
 		return nil
 	})
 }
@@ -109,20 +96,20 @@ func (c *ConversationDataBase) SyncPeerUserPrivateConversationTx(ctx context.Con
 	return c.tx.Transaction(func(tx any) error {
 		userIDList := []string{conversation.OwnerUserID, conversation.UserID}
 		conversationTx := c.conversationDB.NewTx(tx)
-		haveUserID, err := conversationTx.FindUserID(ctx, userIDList, conversation.ConversationID)
+		haveUserIDs, err := conversationTx.FindUserID(ctx, userIDList, conversation.ConversationID)
 		if err != nil {
 			return err
 		}
 		filedMap := map[string]interface{}{"is_private_chat": conversation.IsPrivateChat}
-		if len(haveUserID) > 0 {
-			err = conversationTx.UpdateByMap(ctx, haveUserID, conversation.ConversationID, filedMap)
+		if len(haveUserIDs) > 0 {
+			err = conversationTx.UpdateByMap(ctx, haveUserIDs, conversation.ConversationID, filedMap)
 			if err != nil {
 				return err
 			}
 		}
-		NotUserID := utils.DifferenceString(haveUserID, userIDList)
+		NotUserIDs := utils.DifferenceString(haveUserIDs, userIDList)
 		var cList []*relationTb.ConversationModel
-		for _, v := range NotUserID {
+		for _, v := range NotUserIDs {
 			temp := new(relationTb.ConversationModel)
 			if v == conversation.UserID {
 				temp.OwnerUserID = conversation.UserID
@@ -138,128 +125,71 @@ func (c *ConversationDataBase) SyncPeerUserPrivateConversationTx(ctx context.Con
 			}
 			cList = append(cList, temp)
 		}
-		if len(NotUserID) > 0 {
+		if len(NotUserIDs) > 0 {
 			err = c.conversationDB.Create(ctx, cList)
 			if err != nil {
 				return err
 			}
 		}
-		err = c.cache.DelUsersConversationIDs(ctx, NotUserID)
-		if err != nil {
-			return err
-		}
-		err = c.cache.DelUsersConversation(ctx, haveUserID, conversation.ConversationID)
-		if err != nil {
-			return err
-		}
-		return nil
+		// clear cache
+		return c.cache.DelConversationIDs(NotUserIDs).DelUsersConversation(haveUserIDs, conversation.ConversationID).ExecDel(ctx)
 	})
 }
 
 func (c *ConversationDataBase) FindConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*relationTb.ConversationModel, error) {
-	getConversation := func() (string, error) {
-		conversationList, err := c.conversationDB.Find(ctx, ownerUserID, conversationIDs)
-		if err != nil {
-			return "", utils.Wrap(err, "get failed")
-		}
-		bytes, err := json.Marshal(conversationList)
-		if err != nil {
-			return "", utils.Wrap(err, "Marshal failed")
-		}
-		return string(bytes), nil
-	}
-	return c.cache.GetConversations(ctx, ownerUserID, conversationIDs, getConversation)
+	return c.cache.GetConversations(ctx, ownerUserID, conversationIDs)
 }
 
 func (c *ConversationDataBase) GetConversation(ctx context.Context, ownerUserID string, conversationID string) (*relationTb.ConversationModel, error) {
-	getConversation := func() (string, error) {
-		conversationList, err := c.conversationDB.Take(ctx, ownerUserID, conversationID)
-		if err != nil {
-			return "", utils.Wrap(err, "get failed")
-		}
-		bytes, err := json.Marshal(conversationList)
-		if err != nil {
-			return "", utils.Wrap(err, "Marshal failed")
-		}
-		return string(bytes), nil
-	}
-	return c.cache.GetConversation(ctx, ownerUserID, conversationID, getConversation)
+	return c.cache.GetConversation(ctx, ownerUserID, conversationID)
 }
 
 func (c *ConversationDataBase) GetUserAllConversation(ctx context.Context, ownerUserID string) ([]*relationTb.ConversationModel, error) {
-	getConversationIDs := func() (string, error) {
-		conversationIDs, err := c.conversationDB.FindUserIDAllConversationID(ctx, ownerUserID)
-		if err != nil {
-			return "", utils.Wrap(err, "getConversationIDList failed")
-		}
-		bytes, err := json.Marshal(conversationIDs)
-		if err != nil {
-			return "", utils.Wrap(err, "")
-		}
-		return string(bytes), nil
-	}
-	conversationIDList, err := c.cache.GetUserConversationIDs(ctx, ownerUserID, getConversationIDs)
-	if err != nil {
-		return nil, err
-	}
-	var conversations []*relationTb.ConversationModel
-	for _, conversationID := range conversationIDList {
-		conversation, err := c.GetConversation(ctx, ownerUserID, conversationID)
-		if err != nil {
-			return nil, utils.Wrap(err, "GetConversation failed")
-		}
-		conversations = append(conversations, conversation)
-	}
-	return conversations, nil
+	return c.cache.GetUserAllConversations(ctx, ownerUserID)
 }
 
 func (c *ConversationDataBase) SetUserConversations(ctx context.Context, ownerUserID string, conversations []*relationTb.ConversationModel) error {
 	return c.tx.Transaction(func(tx any) error {
-		var conversationIDList []string
+		var conversationIDs []string
 		for _, conversation := range conversations {
-			conversationIDList = append(conversationIDList, conversation.ConversationID)
+			conversationIDs = append(conversationIDs, conversation.ConversationID)
 		}
 		conversationTx := c.conversationDB.NewTx(tx)
-		haveConversations, err := conversationTx.Find(ctx, ownerUserID, conversationIDList)
+		existConversations, err := conversationTx.Find(ctx, ownerUserID, conversationIDs)
 		if err != nil {
 			return err
 		}
-		if len(haveConversations) > 0 {
+		if len(existConversations) > 0 {
 			err = conversationTx.Update(ctx, conversations)
 			if err != nil {
 				return err
 			}
 		}
-		var haveConversationID []string
-		for _, conversation := range haveConversations {
-			haveConversationID = append(haveConversationID, conversation.ConversationID)
+		var existConversationIDs []string
+		for _, conversation := range existConversations {
+			existConversationIDs = append(existConversationIDs, conversation.ConversationID)
 		}
 
-		NotConversationID := utils.DifferenceString(haveConversationID, conversationIDList)
-		var NotConversations []*relationTb.ConversationModel
+		var notExistConversations []*relationTb.ConversationModel
 		for _, conversation := range conversations {
-			if !utils.IsContain(conversation.ConversationID, haveConversationID) {
-				NotConversations = append(NotConversations, conversation)
+			if !utils.IsContain(conversation.ConversationID, existConversationIDs) {
+				notExistConversations = append(notExistConversations, conversation)
 			}
 		}
-		if len(NotConversations) > 0 {
-			err = c.conversationDB.Create(ctx, NotConversations)
+		if len(notExistConversations) > 0 {
+			err = c.conversationDB.Create(ctx, notExistConversations)
 			if err != nil {
 				return err
 			}
 		}
-		err = c.cache.DelUsersConversationIDs(ctx, NotConversationID)
-		if err != nil {
-			return err
+		cache := c.cache.NewCache()
+		if len(notExistConversations) > 0 {
+			cache = cache.DelConversationIDs([]string{ownerUserID})
 		}
-		err = c.cache.DelUserConversations(ctx, ownerUserID, haveConversationID)
-		if err != nil {
-			return err
-		}
-		return nil
+		return cache.DelConvsersations(ownerUserID, existConversationIDs).ExecDel(ctx)
 	})
 }
 
 func (c *ConversationDataBase) FindRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error) {
-	return c.conversationDB.FindRecvMsgNotNotifyUserIDs(ctx, groupID)
+	return c.cache.GetSuperGroupRecvMsgNotNotifyUserIDs(ctx, groupID)
 }

pkg/common/db/controller/extend_msg.go

@@ -2,7 +2,10 @@ package controller
 
 import (
 	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	unRelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/tx"
 )
 
 // for mongoDB
@@ -18,10 +21,12 @@ type ExtendMsgDatabase interface {
 
 type extendMsgDatabase struct {
 	database unRelationTb.ExtendMsgSetModelInterface
+	cache    cache.ExtendMsgSetCache
+	ctxTx    tx.CtxTx
 }
 
-func NewExtendMsgDatabase(extendMsgModel unRelationTb.ExtendMsgSetModelInterface) ExtendMsgDatabase {
-	return &extendMsgDatabase{database: extendMsgModel}
+func NewExtendMsgDatabase(extendMsgModel unRelationTb.ExtendMsgSetModelInterface, cache cache.ExtendMsgSetCache, ctxTx tx.CtxTx) ExtendMsgDatabase {
+	return &extendMsgDatabase{database: extendMsgModel, cache: cache, ctxTx: ctxTx}
 }
 
 func (e *extendMsgDatabase) CreateExtendMsgSet(ctx context.Context, set *unRelationTb.ExtendMsgSetModel) error {
@@ -41,12 +46,14 @@ func (e *extendMsgDatabase) InsertExtendMsg(ctx context.Context, sourceID string
 }
 
 func (e *extendMsgDatabase) InsertOrUpdateReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*unRelationTb.KeyValueModel) error {
+	e.cache.DelExtendMsg(clientMsgID).ExecDel(ctx)
 	return e.database.InsertOrUpdateReactionExtendMsgSet(ctx, sourceID, sessionType, clientMsgID, msgFirstModifyTime, reactionExtensionList)
 }
+
 func (e *extendMsgDatabase) DeleteReactionExtendMsgSet(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, msgFirstModifyTime int64, reactionExtensionList map[string]*unRelationTb.KeyValueModel) error {
 	return e.database.DeleteReactionExtendMsgSet(ctx, sourceID, sessionType, clientMsgID, msgFirstModifyTime, reactionExtensionList)
 }
 
 func (e *extendMsgDatabase) GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clientMsgID string, maxMsgUpdateTime int64) (extendMsg *unRelationTb.ExtendMsgModel, err error) {
-	return e.database.TakeExtendMsg(ctx, sourceID, sessionType, clientMsgID, maxMsgUpdateTime)
+	return e.cache.GetExtendMsg(ctx, sourceID, sessionType, clientMsgID, maxMsgUpdateTime)
 }

pkg/common/db/controller/friend.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/tx"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
@@ -45,10 +46,11 @@ type friendDatabase struct {
 	friend        relation.FriendModelInterface
 	friendRequest relation.FriendRequestModelInterface
 	tx            tx.Tx
+	cache         cache.FriendCache
 }
 
-func NewFriendDatabase(friend relation.FriendModelInterface, friendRequest relation.FriendRequestModelInterface, tx tx.Tx) FriendDatabase {
-	return &friendDatabase{friend: friend, friendRequest: friendRequest, tx: tx}
+func NewFriendDatabase(friend relation.FriendModelInterface, friendRequest relation.FriendRequestModelInterface, cache cache.FriendCache, tx tx.Tx) FriendDatabase {
+	return &friendDatabase{friend: friend, friendRequest: friendRequest, cache: cache, tx: tx}
 }
 
 // ok 检查user2是否在user1的好友列表中(inUser1Friends==true) 检查user1是否在user2的好友列表中(inUser2Friends==true)
@@ -116,13 +118,14 @@ func (f *friendDatabase) BecomeFriends(ctx context.Context, ownerUserID string,
 		if err != nil {
 			return err
 		}
-
 		fs2, err := f.friend.NewTx(tx).FindReversalFriends(ctx, ownerUserID, friendUserIDs)
 		if err != nil {
 			return err
 		}
+		var newFriendIDs []string
 		for _, v := range friendUserIDs {
 			fs2 = append(fs2, &relation.FriendModel{OwnerUserID: v, FriendUserID: ownerUserID, AddSource: addSource, OperatorUserID: opUserID})
+			newFriendIDs = append(newFriendIDs, v)
 		}
 		fs22 := utils.DistinctAny(fs2, func(e *relation.FriendModel) string {
 			return e.OwnerUserID
@@ -131,7 +134,8 @@ func (f *friendDatabase) BecomeFriends(ctx context.Context, ownerUserID string,
 		if err != nil {
 			return err
 		}
-		return nil
+		newFriendIDs = append(newFriendIDs, ownerUserID)
+		return f.cache.DelFriendIDs(newFriendIDs...).ExecDel(ctx)
 	})
 }
 
@@ -200,18 +204,30 @@ func (f *friendDatabase) AgreeFriendRequest(ctx context.Context, friendRequest *
 		if err != nil {
 			return err
 		}
-		return nil
+		return f.cache.DelFriendIDs(ownerUserID, friendRequest.ToUserID).ExecDel(ctx)
 	})
 }
 
 // 删除好友  外部判断是否好友关系
 func (f *friendDatabase) Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) (err error) {
-	return f.friend.Delete(ctx, ownerUserID, friendUserIDs)
+	return f.tx.Transaction(func(tx any) error {
+		if err := f.friend.Delete(ctx, ownerUserID, friendUserIDs); err != nil {
+			return err
+		}
+		return f.cache.DelFriendIDs(append(friendUserIDs, ownerUserID)...).ExecDel(ctx)
+	})
+
 }
 
 // 更新好友备注 零值也支持
 func (f *friendDatabase) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) {
-	return f.friend.UpdateRemark(ctx, ownerUserID, friendUserID, remark)
+	return f.tx.Transaction(func(tx any) error {
+		err := f.friend.UpdateRemark(ctx, ownerUserID, friendUserID, remark)
+		if err != nil {
+			return err
+		}
+		return f.cache.DelFriend(ownerUserID, friendUserID).ExecDel(ctx)
+	})
 }
 
 // 获取ownerUserID的好友列表 无结果不返回错误
@@ -247,5 +263,5 @@ func (f *friendDatabase) FindFriendsWithError(ctx context.Context, ownerUserID s
 }
 
 func (f *friendDatabase) FindFriendUserIDs(ctx context.Context, ownerUserID string) (friendUserIDs []string, err error) {
-	return f.friend.FindFriendUserIDs(ctx, ownerUserID)
+	return f.cache.GetFriendIDs(ctx, ownerUserID)
 }

pkg/common/db/controller/group.go

@@ -3,6 +3,7 @@ package controller
 import (
 	"context"
 	"fmt"
+
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
@@ -104,26 +105,26 @@ func (g *groupDatabase) GetGroupIDsByGroupType(ctx context.Context, groupType in
 	return g.groupDB.GetGroupIDsByGroupType(ctx, groupType)
 }
 
-func (g *groupDatabase) delGroupMemberCache(ctx context.Context, groupID string, userIDs []string) error {
-	for _, userID := range userIDs {
-		if err := g.cache.DelJoinedGroupID(ctx, userID); err != nil {
-			return err
-		}
-		if err := g.cache.DelJoinedSuperGroupIDs(ctx, userID); err != nil {
-			return err
-		}
-	}
-	if err := g.cache.DelGroupMemberIDs(ctx, groupID); err != nil {
-		return err
-	}
-	if err := g.cache.DelGroupMemberNum(ctx, groupID); err != nil {
-		return err
-	}
-	if err := g.cache.DelGroupMembersHash(ctx, groupID); err != nil {
-		return err
-	}
-	return nil
-}
+// func (g *groupDatabase) delGroupMemberCache(ctx context.Context, groupID string, userIDs []string) error {
+// 	for _, userID := range userIDs {
+// 		if err := g.cache.DelJoinedGroupID(ctx, userID); err != nil {
+// 			return err
+// 		}
+// 		if err := g.cache.DelJoinedSuperGroupIDs(ctx, userID); err != nil {
+// 			return err
+// 		}
+// 	}
+// 	if err := g.cache.DelGroupMemberIDs(ctx, groupID); err != nil {
+// 		return err
+// 	}
+// 	if err := g.cache.DelGroupMemberNum(ctx, groupID); err != nil {
+// 		return err
+// 	}
+// 	if err := g.cache.DelGroupMembersHash(ctx, groupID); err != nil {
+// 		return err
+// 	}
+// 	return nil
+// }
 
 func (g *groupDatabase) FindGroupMemberUserID(ctx context.Context, groupID string) ([]string, error) {
 	return g.cache.GetGroupMemberIDs(ctx, groupID)
@@ -162,10 +163,7 @@ func (g *groupDatabase) UpdateGroup(ctx context.Context, groupID string, data ma
 		if err := g.groupDB.NewTx(tx).UpdateMap(ctx, groupID, data); err != nil {
 			return err
 		}
-		if err := g.cache.DelGroupInfo(ctx, groupID); err != nil {
-			return err
-		}
-		return nil
+		return g.cache.DelGroupsInfo(groupID).ExecDel(ctx)
 	})
 }
 
@@ -181,10 +179,7 @@ func (g *groupDatabase) DismissGroup(ctx context.Context, groupID string) error
 		if err != nil {
 			return err
 		}
-		if err := g.delGroupMemberCache(ctx, groupID, userIDs); err != nil {
-			return err
-		}
-		return nil
+		return g.cache.DelJoinedGroupID(userIDs...).DelGroupsInfo(groupID).DelGroupMemberIDs(groupID).DelGroupsMemberNum(groupID).DelGroupMembersHash(groupID).ExecDel(ctx)
 	})
 }
 
@@ -197,7 +192,7 @@ func (g *groupDatabase) TakeGroupOwner(ctx context.Context, groupID string) (*re
 }
 
 func (g *groupDatabase) FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) ([]*relationTb.GroupMemberModel, error) {
-	return g.groupMemberDB.Find(ctx, groupIDs, userIDs, roleLevels) // todo cache group find
+	return g.cache.GetGroupMembersInfo(ctx, groupIDs[0], userIDs, roleLevels) // todo cache group find
 }
 
 func (g *groupDatabase) PageGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32) (uint32, []*relationTb.GroupMemberModel, error) {
@@ -217,9 +212,7 @@ func (g *groupDatabase) HandlerGroupRequest(ctx context.Context, groupID string,
 			if err := g.groupMemberDB.NewTx(tx).Create(ctx, []*relationTb.GroupMemberModel{member}); err != nil {
 				return err
 			}
-			if err := g.delGroupMemberCache(ctx, groupID, []string{userID}); err != nil {
-				return err
-			}
+			return g.cache.DelGroupMembersHash(groupID).DelGroupMemberIDs(groupID).DelGroupsMemberNum(groupID).DelJoinedGroupID(member.UserID).ExecDel(ctx)
 		}
 		return nil
 	})
@@ -230,15 +223,12 @@ func (g *groupDatabase) DeleteGroupMember(ctx context.Context, groupID string, u
 		if err := g.groupMemberDB.NewTx(tx).Delete(ctx, groupID, userIDs); err != nil {
 			return err
 		}
-		if err := g.delGroupMemberCache(ctx, groupID, userIDs); err != nil {
-			return err
-		}
-		return nil
+		return g.cache.DelGroupMembersHash(groupID).DelGroupMemberIDs(groupID).DelGroupsMemberNum(groupID).DelJoinedGroupID(userIDs...).ExecDel(ctx)
 	})
 }
 
 func (g *groupDatabase) MapGroupMemberUserID(ctx context.Context, groupIDs []string) (map[string]*relationTb.GroupSimpleUserID, error) {
-	return g.cache.GetGroupMemberHash1(ctx, groupIDs)
+	return g.cache.GetGroupMemberHashMap(ctx, groupIDs)
 }
 
 func (g *groupDatabase) MapGroupMemberNum(ctx context.Context, groupIDs []string) (map[string]uint32, error) {
@@ -261,10 +251,7 @@ func (g *groupDatabase) TransferGroupOwner(ctx context.Context, groupID string,
 		if rowsAffected != 1 {
 			return utils.Wrap(fmt.Errorf("newOwnerUserID %s rowsAffected = %d", newOwnerUserID, rowsAffected), "")
 		}
-		if err := g.delGroupMemberCache(ctx, groupID, []string{oldOwnerUserID, newOwnerUserID}); err != nil {
-			return err
-		}
-		return nil
+		return g.cache.DelGroupMembersInfo(groupID, oldOwnerUserID, newOwnerUserID).ExecDel(ctx)
 	})
 }
 
@@ -273,24 +260,20 @@ func (g *groupDatabase) UpdateGroupMember(ctx context.Context, groupID string, u
 		if err := g.groupMemberDB.NewTx(tx).Update(ctx, groupID, userID, data); err != nil {
 			return err
 		}
-		if err := g.cache.DelGroupMemberInfo(ctx, groupID, userID); err != nil {
-			return err
-		}
-		return nil
+		return g.cache.DelGroupMembersInfo(groupID, userID).ExecDel(ctx)
 	})
 }
 
 func (g *groupDatabase) UpdateGroupMembers(ctx context.Context, data []*relationTb.BatchUpdateGroupMember) error {
 	return g.tx.Transaction(func(tx any) error {
+		var cache = g.cache.NewCache()
 		for _, item := range data {
 			if err := g.groupMemberDB.NewTx(tx).Update(ctx, item.GroupID, item.UserID, item.Map); err != nil {
 				return err
 			}
-			if err := g.cache.DelGroupMemberInfo(ctx, item.GroupID, item.UserID); err != nil {
-				return err
-			}
+			cache = cache.DelGroupMembersInfo(item.GroupID, item.UserID)
 		}
-		return nil
+		return cache.ExecDel(ctx)
 	})
 }