feat: use robot to migrate code

Signed-off-by: kubbot & kubecub <3293172751ysy@gmail.com>

pkg/common/db/cache/black.go

@@ -0,0 +1,67 @@
+package cache
+
+import (
+	"context"
+	"time"
+
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/dtm-labs/rockscache"
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	blackIDsKey     = "BLACK_IDS:"
+	blackExpireTime = time.Second * 60 * 60 * 12
+)
+
+// args fn will exec when no data in msgCache
+type BlackCache interface {
+	//get blackIDs from msgCache
+	metaCache
+	NewCache() BlackCache
+	GetBlackIDs(ctx context.Context, userID string) (blackIDs []string, err error)
+	//del user's blackIDs msgCache, exec when a user's black list changed
+	DelBlackIDs(ctx context.Context, userID string) BlackCache
+}
+
+type BlackCacheRedis struct {
+	metaCache
+	expireTime time.Duration
+	rcClient   *rockscache.Client
+	blackDB    relationTb.BlackModelInterface
+}
+
+func NewBlackCacheRedis(rdb redis.UniversalClient, blackDB relationTb.BlackModelInterface, options rockscache.Options) BlackCache {
+	rcClient := rockscache.NewClient(rdb, options)
+	return &BlackCacheRedis{
+		expireTime: blackExpireTime,
+		rcClient:   rcClient,
+		metaCache:  NewMetaCacheRedis(rcClient),
+		blackDB:    blackDB,
+	}
+}
+
+func (b *BlackCacheRedis) NewCache() BlackCache {
+	return &BlackCacheRedis{
+		expireTime: b.expireTime,
+		rcClient:   b.rcClient,
+		blackDB:    b.blackDB,
+		metaCache:  NewMetaCacheRedis(b.rcClient, b.metaCache.GetPreDelKeys()...),
+	}
+}
+
+func (b *BlackCacheRedis) getBlackIDsKey(ownerUserID string) string {
+	return blackIDsKey + ownerUserID
+}
+
+func (b *BlackCacheRedis) GetBlackIDs(ctx context.Context, userID string) (blackIDs []string, err error) {
+	return getCache(ctx, b.rcClient, b.getBlackIDsKey(userID), b.expireTime, func(ctx context.Context) ([]string, error) {
+		return b.blackDB.FindBlackUserIDs(ctx, userID)
+	})
+}
+
+func (b *BlackCacheRedis) DelBlackIDs(ctx context.Context, userID string) BlackCache {
+	cache := b.NewCache()
+	cache.AddKeys(b.getBlackIDsKey(userID))
+	return cache
+}

pkg/common/db/cache/conversation.go

@@ -0,0 +1,293 @@
+package cache
+
+import (
+	"context"
+	"errors"
+	"math/big"
+	"strings"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/dtm-labs/rockscache"
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	conversationKey                          = "CONVERSATION:"
+	conversationIDsKey                       = "CONVERSATION_IDS:"
+	conversationIDsHashKey                   = "CONVERSATION_IDS_HASH:"
+	conversationHasReadSeqKey                = "CONVERSATION_HAS_READ_SEQ:"
+	recvMsgOptKey                            = "RECV_MSG_OPT:"
+	superGroupRecvMsgNotNotifyUserIDsKey     = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS:"
+	superGroupRecvMsgNotNotifyUserIDsHashKey = "SUPER_GROUP_RECV_MSG_NOT_NOTIFY_USER_IDS_HASH:"
+
+	conversationExpireTime = time.Second * 60 * 60 * 12
+)
+
+// arg fn will exec when no data in msgCache
+type ConversationCache interface {
+	metaCache
+	NewCache() ConversationCache
+	// get user's conversationIDs from msgCache
+	GetUserConversationIDs(ctx context.Context, ownerUserID string) ([]string, error)
+	DelConversationIDs(userIDs ...string) ConversationCache
+
+	GetUserConversationIDsHash(ctx context.Context, ownerUserID string) (hash uint64, err error)
+	DelUserConversationIDsHash(ownerUserIDs ...string) ConversationCache
+
+	// get one conversation from msgCache
+	GetConversation(ctx context.Context, ownerUserID, conversationID string) (*relationTb.ConversationModel, error)
+	DelConvsersations(ownerUserID string, conversationIDs ...string) ConversationCache
+	DelUsersConversation(conversationID string, ownerUserIDs ...string) ConversationCache
+	// get one conversation from msgCache
+	GetConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*relationTb.ConversationModel, error)
+	// get one user's all conversations from msgCache
+	GetUserAllConversations(ctx context.Context, ownerUserID string) ([]*relationTb.ConversationModel, error)
+	// get user conversation recv msg from msgCache
+	GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error)
+	DelUserRecvMsgOpt(ownerUserID, conversationID string) ConversationCache
+	// get one super group recv msg but do not notification userID list
+	GetSuperGroupRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) (userIDs []string, err error)
+	DelSuperGroupRecvMsgNotNotifyUserIDs(groupID string) ConversationCache
+	// get one super group recv msg but do not notification userID list hash
+	GetSuperGroupRecvMsgNotNotifyUserIDsHash(ctx context.Context, groupID string) (hash uint64, err error)
+	DelSuperGroupRecvMsgNotNotifyUserIDsHash(groupID string) ConversationCache
+
+	GetUserAllHasReadSeqs(ctx context.Context, ownerUserID string) (map[string]int64, error)
+	DelUserAllHasReadSeqs(ownerUserID string, conversationIDs ...string) ConversationCache
+
+	GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*relationTb.ConversationModel, error)
+	DelConversationByConversationID(conversationIDs ...string) ConversationCache
+}
+
+func NewConversationRedis(rdb redis.UniversalClient, opts rockscache.Options, db relationTb.ConversationModelInterface) ConversationCache {
+	rcClient := rockscache.NewClient(rdb, opts)
+	return &ConversationRedisCache{rcClient: rcClient, metaCache: NewMetaCacheRedis(rcClient), conversationDB: db, expireTime: conversationExpireTime}
+}
+
+type ConversationRedisCache struct {
+	metaCache
+	rcClient       *rockscache.Client
+	conversationDB relationTb.ConversationModelInterface
+	expireTime     time.Duration
+}
+
+func NewNewConversationRedis(rdb redis.UniversalClient, conversationDB *relation.ConversationGorm, options rockscache.Options) ConversationCache {
+	rcClient := rockscache.NewClient(rdb, options)
+	return &ConversationRedisCache{rcClient: rcClient, metaCache: NewMetaCacheRedis(rcClient), conversationDB: conversationDB, expireTime: conversationExpireTime}
+}
+
+func (c *ConversationRedisCache) NewCache() ConversationCache {
+	return &ConversationRedisCache{rcClient: c.rcClient, metaCache: NewMetaCacheRedis(c.rcClient, c.metaCache.GetPreDelKeys()...), conversationDB: c.conversationDB, expireTime: c.expireTime}
+}
+
+func (c *ConversationRedisCache) getConversationKey(ownerUserID, conversationID string) string {
+	return conversationKey + ownerUserID + ":" + conversationID
+}
+
+func (c *ConversationRedisCache) getConversationIDsKey(ownerUserID string) string {
+	return conversationIDsKey + ownerUserID
+}
+
+func (c *ConversationRedisCache) getSuperGroupRecvNotNotifyUserIDsKey(groupID string) string {
+	return superGroupRecvMsgNotNotifyUserIDsKey + groupID
+}
+
+func (c *ConversationRedisCache) getRecvMsgOptKey(ownerUserID, conversationID string) string {
+	return recvMsgOptKey + ownerUserID + ":" + conversationID
+}
+
+func (c *ConversationRedisCache) getSuperGroupRecvNotNotifyUserIDsHashKey(groupID string) string {
+	return superGroupRecvMsgNotNotifyUserIDsHashKey + groupID
+}
+
+func (c *ConversationRedisCache) getConversationHasReadSeqKey(ownerUserID, conversationID string) string {
+	return conversationHasReadSeqKey + ownerUserID + ":" + conversationID
+}
+
+func (c *ConversationRedisCache) GetUserConversationIDs(ctx context.Context, ownerUserID string) ([]string, error) {
+	return getCache(ctx, c.rcClient, c.getConversationIDsKey(ownerUserID), c.expireTime, func(ctx context.Context) ([]string, error) {
+		return c.conversationDB.FindUserIDAllConversationID(ctx, ownerUserID)
+	})
+}
+
+func (c *ConversationRedisCache) DelConversationIDs(userIDs ...string) ConversationCache {
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, c.getConversationIDsKey(userID))
+	}
+	cache := c.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}
+
+func (c *ConversationRedisCache) getUserConversationIDsHashKey(ownerUserID string) string {
+	return conversationIDsHashKey + ownerUserID
+}
+
+func (c *ConversationRedisCache) GetUserConversationIDsHash(ctx context.Context, ownerUserID string) (hash uint64, err error) {
+	return getCache(ctx, c.rcClient, c.getUserConversationIDsHashKey(ownerUserID), c.expireTime, func(ctx context.Context) (uint64, error) {
+		conversationIDs, err := c.GetUserConversationIDs(ctx, ownerUserID)
+		if err != nil {
+			return 0, err
+		}
+		utils.Sort(conversationIDs, true)
+		bi := big.NewInt(0)
+		bi.SetString(utils.Md5(strings.Join(conversationIDs, ";"))[0:8], 16)
+		return bi.Uint64(), nil
+	})
+}
+
+func (c *ConversationRedisCache) DelUserConversationIDsHash(ownerUserIDs ...string) ConversationCache {
+	var keys []string
+	for _, ownerUserID := range ownerUserIDs {
+		keys = append(keys, c.getUserConversationIDsHashKey(ownerUserID))
+	}
+	cache := c.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}
+
+func (c *ConversationRedisCache) GetConversation(ctx context.Context, ownerUserID, conversationID string) (*relationTb.ConversationModel, error) {
+	return getCache(ctx, c.rcClient, c.getConversationKey(ownerUserID, conversationID), c.expireTime, func(ctx context.Context) (*relationTb.ConversationModel, error) {
+		return c.conversationDB.Take(ctx, ownerUserID, conversationID)
+	})
+}
+
+func (c *ConversationRedisCache) DelConvsersations(ownerUserID string, convsersationIDs ...string) ConversationCache {
+	var keys []string
+	for _, conversationID := range convsersationIDs {
+		keys = append(keys, c.getConversationKey(ownerUserID, conversationID))
+	}
+	cache := c.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}
+
+func (c *ConversationRedisCache) getConversationIndex(convsation *relationTb.ConversationModel, keys []string) (int, error) {
+	key := c.getConversationKey(convsation.OwnerUserID, convsation.ConversationID)
+	for _i, _key := range keys {
+		if _key == key {
+			return _i, nil
+		}
+	}
+	return 0, errors.New("not found key:" + key + " in keys")
+}
+
+func (c *ConversationRedisCache) GetConversations(ctx context.Context, ownerUserID string, conversationIDs []string) ([]*relationTb.ConversationModel, error) {
+	var keys []string
+	for _, conversarionID := range conversationIDs {
+		keys = append(keys, c.getConversationKey(ownerUserID, conversarionID))
+	}
+	return batchGetCache(ctx, c.rcClient, keys, c.expireTime, c.getConversationIndex, func(ctx context.Context) ([]*relationTb.ConversationModel, error) {
+		return c.conversationDB.Find(ctx, ownerUserID, conversationIDs)
+	})
+}
+
+func (c *ConversationRedisCache) GetUserAllConversations(ctx context.Context, ownerUserID string) ([]*relationTb.ConversationModel, error) {
+	conversationIDs, err := c.GetUserConversationIDs(ctx, ownerUserID)
+	if err != nil {
+		return nil, err
+	}
+	var keys []string
+	for _, conversarionID := range conversationIDs {
+		keys = append(keys, c.getConversationKey(ownerUserID, conversarionID))
+	}
+	return batchGetCache(ctx, c.rcClient, keys, c.expireTime, c.getConversationIndex, func(ctx context.Context) ([]*relationTb.ConversationModel, error) {
+		return c.conversationDB.FindUserIDAllConversations(ctx, ownerUserID)
+	})
+}
+
+func (c *ConversationRedisCache) GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error) {
+	return getCache(ctx, c.rcClient, c.getRecvMsgOptKey(ownerUserID, conversationID), c.expireTime, func(ctx context.Context) (opt int, err error) {
+		return c.conversationDB.GetUserRecvMsgOpt(ctx, ownerUserID, conversationID)
+	})
+}
+
+func (c *ConversationRedisCache) GetSuperGroupRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) (userIDs []string, err error) {
+	return getCache(ctx, c.rcClient, c.getSuperGroupRecvNotNotifyUserIDsKey(groupID), c.expireTime, func(ctx context.Context) (userIDs []string, err error) {
+		return c.conversationDB.FindSuperGroupRecvMsgNotNotifyUserIDs(ctx, groupID)
+	})
+}
+
+func (c *ConversationRedisCache) DelUsersConversation(conversationID string, ownerUserIDs ...string) ConversationCache {
+	var keys []string
+	for _, ownerUserID := range ownerUserIDs {
+		keys = append(keys, c.getConversationKey(ownerUserID, conversationID))
+	}
+	cache := c.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}
+
+func (c *ConversationRedisCache) DelUserRecvMsgOpt(ownerUserID, conversationID string) ConversationCache {
+	cache := c.NewCache()
+	cache.AddKeys(c.getRecvMsgOptKey(ownerUserID, conversationID))
+	return cache
+}
+
+func (c *ConversationRedisCache) DelSuperGroupRecvMsgNotNotifyUserIDs(groupID string) ConversationCache {
+	cache := c.NewCache()
+	cache.AddKeys(c.getSuperGroupRecvNotNotifyUserIDsKey(groupID))
+	return cache
+}
+
+func (c *ConversationRedisCache) GetSuperGroupRecvMsgNotNotifyUserIDsHash(ctx context.Context, groupID string) (hash uint64, err error) {
+	return getCache(ctx, c.rcClient, c.getSuperGroupRecvNotNotifyUserIDsHashKey(groupID), c.expireTime, func(ctx context.Context) (hash uint64, err error) {
+		userIDs, err := c.GetSuperGroupRecvMsgNotNotifyUserIDs(ctx, groupID)
+		if err != nil {
+			return 0, err
+		}
+		utils.Sort(userIDs, true)
+		bi := big.NewInt(0)
+		bi.SetString(utils.Md5(strings.Join(userIDs, ";"))[0:8], 16)
+		return bi.Uint64(), nil
+	})
+}
+
+func (c *ConversationRedisCache) DelSuperGroupRecvMsgNotNotifyUserIDsHash(groupID string) ConversationCache {
+	cache := c.NewCache()
+	cache.AddKeys(c.getSuperGroupRecvNotNotifyUserIDsHashKey(groupID))
+	return cache
+}
+
+func (c *ConversationRedisCache) getUserAllHasReadSeqsIndex(conversationID string, conversationIDs []string) (int, error) {
+	for _i, _conversationID := range conversationIDs {
+		if _conversationID == conversationID {
+			return _i, nil
+		}
+	}
+	return 0, errors.New("not found key:" + conversationID + " in keys")
+}
+
+func (c *ConversationRedisCache) GetUserAllHasReadSeqs(ctx context.Context, ownerUserID string) (map[string]int64, error) {
+	conversationIDs, err := c.GetUserConversationIDs(ctx, ownerUserID)
+	if err != nil {
+		return nil, err
+	}
+	var keys []string
+	for _, conversarionID := range conversationIDs {
+		keys = append(keys, c.getConversationHasReadSeqKey(ownerUserID, conversarionID))
+	}
+	return batchGetCacheMap(ctx, c.rcClient, keys, conversationIDs, c.expireTime, c.getUserAllHasReadSeqsIndex, func(ctx context.Context) (map[string]int64, error) {
+		return c.conversationDB.GetUserAllHasReadSeqs(ctx, ownerUserID)
+	})
+}
+
+func (c *ConversationRedisCache) DelUserAllHasReadSeqs(ownerUserID string, conversationIDs ...string) ConversationCache {
+	cache := c.NewCache()
+	for _, conversationID := range conversationIDs {
+		cache.AddKeys(c.getConversationHasReadSeqKey(ownerUserID, conversationID))
+	}
+	return cache
+}
+
+func (c *ConversationRedisCache) GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*relationTb.ConversationModel, error) {
+	panic("implement me")
+}
+
+func (c *ConversationRedisCache) DelConversationByConversationID(conversationIDs ...string) ConversationCache {
+	panic("implement me")
+}

pkg/common/db/cache/extend_msg_set.go

@@ -0,0 +1,64 @@
+package cache
+
+import (
+	"context"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/dtm-labs/rockscache"
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	extendMsgSetCache = "EXTEND_MSG_SET_CACHE:"
+	extendMsgCache    = "EXTEND_MSG_CACHE:"
+)
+
+type ExtendMsgSetCache interface {
+	metaCache
+	NewCache() ExtendMsgSetCache
+	GetExtendMsg(ctx context.Context, conversationID string, sessionType int32, clientMsgID string, firstModifyTime int64) (extendMsg *unrelation.ExtendMsgModel, err error)
+	DelExtendMsg(clientMsgID string) ExtendMsgSetCache
+}
+
+type ExtendMsgSetCacheRedis struct {
+	metaCache
+	expireTime     time.Duration
+	rcClient       *rockscache.Client
+	extendMsgSetDB unrelation.ExtendMsgSetModelInterface
+}
+
+func NewExtendMsgSetCacheRedis(rdb redis.UniversalClient, extendMsgSetDB unrelation.ExtendMsgSetModelInterface, options rockscache.Options) ExtendMsgSetCache {
+	rcClient := rockscache.NewClient(rdb, options)
+	return &ExtendMsgSetCacheRedis{
+		metaCache:      NewMetaCacheRedis(rcClient),
+		expireTime:     time.Second * 30 * 60,
+		extendMsgSetDB: extendMsgSetDB,
+		rcClient:       rcClient,
+	}
+}
+
+func (e *ExtendMsgSetCacheRedis) NewCache() ExtendMsgSetCache {
+	return &ExtendMsgSetCacheRedis{
+		metaCache:      NewMetaCacheRedis(e.rcClient, e.metaCache.GetPreDelKeys()...),
+		expireTime:     e.expireTime,
+		extendMsgSetDB: e.extendMsgSetDB,
+		rcClient:       e.rcClient,
+	}
+}
+
+func (e *ExtendMsgSetCacheRedis) getKey(clientMsgID string) string {
+	return extendMsgCache + clientMsgID
+}
+
+func (e *ExtendMsgSetCacheRedis) GetExtendMsg(ctx context.Context, conversationID string, sessionType int32, clientMsgID string, firstModifyTime int64) (extendMsg *unrelation.ExtendMsgModel, err error) {
+	return getCache(ctx, e.rcClient, e.getKey(clientMsgID), e.expireTime, func(ctx context.Context) (*unrelation.ExtendMsgModel, error) {
+		return e.extendMsgSetDB.TakeExtendMsg(ctx, conversationID, sessionType, clientMsgID, firstModifyTime)
+	})
+}
+
+func (e *ExtendMsgSetCacheRedis) DelExtendMsg(clientMsgID string) ExtendMsgSetCache {
+	new := e.NewCache()
+	new.AddKeys(e.getKey(clientMsgID))
+	return new
+}

pkg/common/db/cache/friend.go

@@ -0,0 +1,116 @@
+package cache
+
+import (
+	"context"
+	"time"
+
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/dtm-labs/rockscache"
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	friendExpireTime    = time.Second * 60 * 60 * 12
+	friendIDsKey        = "FRIEND_IDS:"
+	TwoWayFriendsIDsKey = "COMMON_FRIENDS_IDS:"
+	friendKey           = "FRIEND_INFO:"
+)
+
+// args fn will exec when no data in msgCache
+type FriendCache interface {
+	metaCache
+	NewCache() FriendCache
+	GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error)
+	// call when friendID List changed
+	DelFriendIDs(ownerUserID ...string) FriendCache
+	// get single friendInfo from msgCache
+	GetFriend(ctx context.Context, ownerUserID, friendUserID string) (friend *relationTb.FriendModel, err error)
+	// del friend when friend info changed
+	DelFriend(ownerUserID, friendUserID string) FriendCache
+}
+
+type FriendCacheRedis struct {
+	metaCache
+	friendDB   relationTb.FriendModelInterface
+	expireTime time.Duration
+	rcClient   *rockscache.Client
+}
+
+func NewFriendCacheRedis(rdb redis.UniversalClient, friendDB relationTb.FriendModelInterface, options rockscache.Options) FriendCache {
+	rcClient := rockscache.NewClient(rdb, options)
+	return &FriendCacheRedis{
+		metaCache:  NewMetaCacheRedis(rcClient),
+		friendDB:   friendDB,
+		expireTime: friendExpireTime,
+		rcClient:   rcClient,
+	}
+}
+
+func (c *FriendCacheRedis) NewCache() FriendCache {
+	return &FriendCacheRedis{rcClient: c.rcClient, metaCache: NewMetaCacheRedis(c.rcClient, c.metaCache.GetPreDelKeys()...), friendDB: c.friendDB, expireTime: c.expireTime}
+}
+
+func (f *FriendCacheRedis) getFriendIDsKey(ownerUserID string) string {
+	return friendIDsKey + ownerUserID
+}
+
+func (f *FriendCacheRedis) getTwoWayFriendsIDsKey(ownerUserID string) string {
+	return TwoWayFriendsIDsKey + ownerUserID
+}
+
+func (f *FriendCacheRedis) getFriendKey(ownerUserID, friendUserID string) string {
+	return friendKey + ownerUserID + "-" + friendUserID
+}
+
+func (f *FriendCacheRedis) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error) {
+	return getCache(ctx, f.rcClient, f.getFriendIDsKey(ownerUserID), f.expireTime, func(ctx context.Context) ([]string, error) {
+		return f.friendDB.FindFriendUserIDs(ctx, ownerUserID)
+	})
+}
+
+func (f *FriendCacheRedis) DelFriendIDs(ownerUserID ...string) FriendCache {
+	new := f.NewCache()
+	var keys []string
+	for _, userID := range ownerUserID {
+		keys = append(keys, f.getFriendIDsKey(userID))
+	}
+	new.AddKeys(keys...)
+	return new
+}
+
+// todo
+func (f *FriendCacheRedis) GetTwoWayFriendIDs(ctx context.Context, ownerUserID string) (twoWayFriendIDs []string, err error) {
+	friendIDs, err := f.GetFriendIDs(ctx, ownerUserID)
+	if err != nil {
+		return nil, err
+	}
+	for _, friendID := range friendIDs {
+		friendFriendID, err := f.GetFriendIDs(ctx, friendID)
+		if err != nil {
+			return nil, err
+		}
+		if utils.IsContain(ownerUserID, friendFriendID) {
+			twoWayFriendIDs = append(twoWayFriendIDs, ownerUserID)
+		}
+	}
+	return twoWayFriendIDs, nil
+}
+
+func (f *FriendCacheRedis) DelTwoWayFriendIDs(ctx context.Context, ownerUserID string) FriendCache {
+	new := f.NewCache()
+	new.AddKeys(f.getTwoWayFriendsIDsKey(ownerUserID))
+	return new
+}
+
+func (f *FriendCacheRedis) GetFriend(ctx context.Context, ownerUserID, friendUserID string) (friend *relationTb.FriendModel, err error) {
+	return getCache(ctx, f.rcClient, f.getFriendKey(ownerUserID, friendUserID), f.expireTime, func(ctx context.Context) (*relationTb.FriendModel, error) {
+		return f.friendDB.Take(ctx, ownerUserID, friendUserID)
+	})
+}
+
+func (f *FriendCacheRedis) DelFriend(ownerUserID, friendUserID string) FriendCache {
+	new := f.NewCache()
+	new.AddKeys(f.getFriendKey(ownerUserID, friendUserID))
+	return new
+}

pkg/common/db/cache/group.go

@@ -0,0 +1,365 @@
+package cache
+
+import (
+	"context"
+	"math/big"
+	"strings"
+	"time"
+
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	unrelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/dtm-labs/rockscache"
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	groupExpireTime        = time.Second * 60 * 60 * 12
+	groupInfoKey           = "GROUP_INFO:"
+	groupMemberIDsKey      = "GROUP_MEMBER_IDS:"
+	groupMembersHashKey    = "GROUP_MEMBERS_HASH:"
+	groupMemberInfoKey     = "GROUP_MEMBER_INFO:"
+	joinedSuperGroupsKey   = "JOIN_SUPER_GROUPS:"
+	SuperGroupMemberIDsKey = "SUPER_GROUP_MEMBER_IDS:"
+	joinedGroupsKey        = "JOIN_GROUPS_KEY:"
+	groupMemberNumKey      = "GROUP_MEMBER_NUM_CACHE:"
+)
+
+type GroupCache interface {
+	metaCache
+	NewCache() GroupCache
+	GetGroupsInfo(ctx context.Context, groupIDs []string) (groups []*relationTb.GroupModel, err error)
+	GetGroupInfo(ctx context.Context, groupID string) (group *relationTb.GroupModel, err error)
+	DelGroupsInfo(groupIDs ...string) GroupCache
+
+	GetJoinedSuperGroupIDs(ctx context.Context, userID string) (joinedSuperGroupIDs []string, err error)
+	DelJoinedSuperGroupIDs(userIDs ...string) GroupCache
+	GetSuperGroupMemberIDs(ctx context.Context, groupIDs ...string) (models []*unrelationTb.SuperGroupModel, err error)
+	DelSuperGroupMemberIDs(groupIDs ...string) GroupCache
+
+	GetGroupMembersHash(ctx context.Context, groupID string) (hashCode uint64, err error)
+	GetGroupMemberHashMap(ctx context.Context, groupIDs []string) (map[string]*relationTb.GroupSimpleUserID, error)
+	DelGroupMembersHash(groupID string) GroupCache
+
+	GetGroupMemberIDs(ctx context.Context, groupID string) (groupMemberIDs []string, err error)
+	GetGroupsMemberIDs(ctx context.Context, groupIDs []string) (groupMemberIDs map[string][]string, err error)
+
+	DelGroupMemberIDs(groupID string) GroupCache
+
+	GetJoinedGroupIDs(ctx context.Context, userID string) (joinedGroupIDs []string, err error)
+	DelJoinedGroupID(userID ...string) GroupCache
+
+	GetGroupMemberInfo(ctx context.Context, groupID, userID string) (groupMember *relationTb.GroupMemberModel, err error)
+	GetGroupMembersInfo(ctx context.Context, groupID string, userID []string) (groupMembers []*relationTb.GroupMemberModel, err error)
+	GetAllGroupMembersInfo(ctx context.Context, groupID string) (groupMembers []*relationTb.GroupMemberModel, err error)
+	GetGroupMembersPage(ctx context.Context, groupID string, userID []string, showNumber, pageNumber int32) (total uint32, groupMembers []*relationTb.GroupMemberModel, err error)
+
+	DelGroupMembersInfo(groupID string, userID ...string) GroupCache
+
+	GetGroupMemberNum(ctx context.Context, groupID string) (memberNum int64, err error)
+	DelGroupsMemberNum(groupID ...string) GroupCache
+}
+
+type GroupCacheRedis struct {
+	metaCache
+	groupDB        relationTb.GroupModelInterface
+	groupMemberDB  relationTb.GroupMemberModelInterface
+	groupRequestDB relationTb.GroupRequestModelInterface
+	mongoDB        unrelationTb.SuperGroupModelInterface
+	expireTime     time.Duration
+	rcClient       *rockscache.Client
+}
+
+func NewGroupCacheRedis(rdb redis.UniversalClient, groupDB relationTb.GroupModelInterface, groupMemberDB relationTb.GroupMemberModelInterface, groupRequestDB relationTb.GroupRequestModelInterface, mongoClient unrelationTb.SuperGroupModelInterface, opts rockscache.Options) GroupCache {
+	rcClient := rockscache.NewClient(rdb, opts)
+	return &GroupCacheRedis{rcClient: rcClient, expireTime: groupExpireTime,
+		groupDB: groupDB, groupMemberDB: groupMemberDB, groupRequestDB: groupRequestDB,
+		mongoDB: mongoClient, metaCache: NewMetaCacheRedis(rcClient),
+	}
+}
+
+func (g *GroupCacheRedis) NewCache() GroupCache {
+	return &GroupCacheRedis{rcClient: g.rcClient, expireTime: g.expireTime, groupDB: g.groupDB, groupMemberDB: g.groupMemberDB, groupRequestDB: g.groupRequestDB, mongoDB: g.mongoDB, metaCache: NewMetaCacheRedis(g.rcClient, g.metaCache.GetPreDelKeys()...)}
+}
+
+func (g *GroupCacheRedis) getGroupInfoKey(groupID string) string {
+	return groupInfoKey + groupID
+}
+
+func (g *GroupCacheRedis) getJoinedSuperGroupsIDKey(userID string) string {
+	return joinedSuperGroupsKey + userID
+}
+
+func (g *GroupCacheRedis) getJoinedGroupsKey(userID string) string {
+	return joinedGroupsKey + userID
+}
+
+func (g *GroupCacheRedis) getSuperGroupMemberIDsKey(groupID string) string {
+	return SuperGroupMemberIDsKey + groupID
+}
+
+func (g *GroupCacheRedis) getGroupMembersHashKey(groupID string) string {
+	return groupMembersHashKey + groupID
+}
+
+func (g *GroupCacheRedis) getGroupMemberIDsKey(groupID string) string {
+	return groupMemberIDsKey + groupID
+}
+
+func (g *GroupCacheRedis) getGroupMemberInfoKey(groupID, userID string) string {
+	return groupMemberInfoKey + groupID + "-" + userID
+}
+
+func (g *GroupCacheRedis) getGroupMemberNumKey(groupID string) string {
+	return groupMemberNumKey + groupID
+}
+
+func (g *GroupCacheRedis) GetGroupIndex(group *relationTb.GroupModel, keys []string) (int, error) {
+	key := g.getGroupInfoKey(group.GroupID)
+	for i, _key := range keys {
+		if _key == key {
+			return i, nil
+		}
+	}
+	return 0, errIndex
+}
+
+func (g *GroupCacheRedis) GetGroupMemberIndex(groupMember *relationTb.GroupMemberModel, keys []string) (int, error) {
+	key := g.getGroupMemberInfoKey(groupMember.GroupID, groupMember.UserID)
+	for i, _key := range keys {
+		if _key == key {
+			return i, nil
+		}
+	}
+	return 0, errIndex
+}
+
+// / groupInfo
+func (g *GroupCacheRedis) GetGroupsInfo(ctx context.Context, groupIDs []string) (groups []*relationTb.GroupModel, err error) {
+	var keys []string
+	for _, group := range groupIDs {
+		keys = append(keys, g.getGroupInfoKey(group))
+	}
+	return batchGetCache(ctx, g.rcClient, keys, g.expireTime, g.GetGroupIndex, func(ctx context.Context) ([]*relationTb.GroupModel, error) {
+		return g.groupDB.Find(ctx, groupIDs)
+	})
+}
+
+func (g *GroupCacheRedis) GetGroupInfo(ctx context.Context, groupID string) (group *relationTb.GroupModel, err error) {
+	return getCache(ctx, g.rcClient, g.getGroupInfoKey(groupID), g.expireTime, func(ctx context.Context) (*relationTb.GroupModel, error) {
+		return g.groupDB.Take(ctx, groupID)
+	})
+}
+
+func (g *GroupCacheRedis) DelGroupsInfo(groupIDs ...string) GroupCache {
+	new := g.NewCache()
+	var keys []string
+	for _, groupID := range groupIDs {
+		keys = append(keys, g.getGroupInfoKey(groupID))
+	}
+	new.AddKeys(keys...)
+	return new
+}
+
+func (g *GroupCacheRedis) GetJoinedSuperGroupIDs(ctx context.Context, userID string) (joinedSuperGroupIDs []string, err error) {
+	return getCache(ctx, g.rcClient, g.getJoinedSuperGroupsIDKey(userID), g.expireTime, func(ctx context.Context) ([]string, error) {
+		userGroup, err := g.mongoDB.GetSuperGroupByUserID(ctx, userID)
+		if err != nil {
+			return nil, err
+		}
+		return userGroup.GroupIDs, nil
+	})
+}
+
+func (g *GroupCacheRedis) GetSuperGroupMemberIDs(ctx context.Context, groupIDs ...string) (models []*unrelationTb.SuperGroupModel, err error) {
+	var keys []string
+	for _, group := range groupIDs {
+		keys = append(keys, g.getSuperGroupMemberIDsKey(group))
+	}
+	return batchGetCache(ctx, g.rcClient, keys, g.expireTime, func(model *unrelationTb.SuperGroupModel, keys []string) (int, error) {
+		for i, key := range keys {
+			if g.getSuperGroupMemberIDsKey(model.GroupID) == key {
+				return i, nil
+			}
+		}
+		return 0, errIndex
+	}, func(ctx context.Context) ([]*unrelationTb.SuperGroupModel, error) {
+		return g.mongoDB.FindSuperGroup(ctx, groupIDs)
+	})
+}
+
+// userJoinSuperGroup
+func (g *GroupCacheRedis) DelJoinedSuperGroupIDs(userIDs ...string) GroupCache {
+	new := g.NewCache()
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, g.getJoinedSuperGroupsIDKey(userID))
+	}
+	new.AddKeys(keys...)
+	return new
+}
+
+func (g *GroupCacheRedis) DelSuperGroupMemberIDs(groupIDs ...string) GroupCache {
+	new := g.NewCache()
+	var keys []string
+	for _, groupID := range groupIDs {
+		keys = append(keys, g.getSuperGroupMemberIDsKey(groupID))
+	}
+	new.AddKeys(keys...)
+	return new
+}
+
+// groupMembersHash
+func (g *GroupCacheRedis) GetGroupMembersHash(ctx context.Context, groupID string) (hashCode uint64, err error) {
+	return getCache(ctx, g.rcClient, g.getGroupMembersHashKey(groupID), g.expireTime, func(ctx context.Context) (uint64, error) {
+		userIDs, err := g.GetGroupMemberIDs(ctx, groupID)
+		if err != nil {
+			return 0, err
+		}
+		utils.Sort(userIDs, true)
+		bi := big.NewInt(0)
+		bi.SetString(utils.Md5(strings.Join(userIDs, ";"))[0:8], 16)
+		return bi.Uint64(), nil
+	})
+}
+
+func (g *GroupCacheRedis) GetGroupMemberHashMap(ctx context.Context, groupIDs []string) (map[string]*relationTb.GroupSimpleUserID, error) {
+	res := make(map[string]*relationTb.GroupSimpleUserID)
+	for _, groupID := range groupIDs {
+		hash, err := g.GetGroupMembersHash(ctx, groupID)
+		if err != nil {
+			return nil, err
+		}
+		num, err := g.GetGroupMemberNum(ctx, groupID)
+		if err != nil {
+			return nil, err
+		}
+		res[groupID] = &relationTb.GroupSimpleUserID{Hash: hash, MemberNum: uint32(num)}
+	}
+	return res, nil
+}
+
+func (g *GroupCacheRedis) DelGroupMembersHash(groupID string) GroupCache {
+	cache := g.NewCache()
+	cache.AddKeys(g.getGroupMembersHashKey(groupID))
+	return cache
+}
+
+// groupMemberIDs
+func (g *GroupCacheRedis) GetGroupMemberIDs(ctx context.Context, groupID string) (groupMemberIDs []string, err error) {
+	return getCache(ctx, g.rcClient, g.getGroupMemberIDsKey(groupID), g.expireTime, func(ctx context.Context) ([]string, error) {
+		return g.groupMemberDB.FindMemberUserID(ctx, groupID)
+	})
+}
+
+func (g *GroupCacheRedis) GetGroupsMemberIDs(ctx context.Context, groupIDs []string) (map[string][]string, error) {
+	m := make(map[string][]string)
+	for _, groupID := range groupIDs {
+		userIDs, err := g.GetGroupMemberIDs(ctx, groupID)
+		if err != nil {
+			return nil, err
+		}
+		m[groupID] = userIDs
+	}
+	return m, nil
+}
+
+func (g *GroupCacheRedis) DelGroupMemberIDs(groupID string) GroupCache {
+	cache := g.NewCache()
+	cache.AddKeys(g.getGroupMemberIDsKey(groupID))
+	return cache
+}
+
+func (g *GroupCacheRedis) GetJoinedGroupIDs(ctx context.Context, userID string) (joinedGroupIDs []string, err error) {
+	return getCache(ctx, g.rcClient, g.getJoinedGroupsKey(userID), g.expireTime, func(ctx context.Context) ([]string, error) {
+		return g.groupMemberDB.FindUserJoinedGroupID(ctx, userID)
+	})
+}
+
+func (g *GroupCacheRedis) DelJoinedGroupID(userIDs ...string) GroupCache {
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, g.getJoinedGroupsKey(userID))
+	}
+	cache := g.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}
+
+func (g *GroupCacheRedis) GetGroupMemberInfo(ctx context.Context, groupID, userID string) (groupMember *relationTb.GroupMemberModel, err error) {
+	return getCache(ctx, g.rcClient, g.getGroupMemberInfoKey(groupID, userID), g.expireTime, func(ctx context.Context) (*relationTb.GroupMemberModel, error) {
+		return g.groupMemberDB.Take(ctx, groupID, userID)
+	})
+}
+
+func (g *GroupCacheRedis) GetGroupMembersInfo(ctx context.Context, groupID string, userIDs []string) ([]*relationTb.GroupMemberModel, error) {
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, g.getGroupMemberInfoKey(groupID, userID))
+	}
+	return batchGetCache(ctx, g.rcClient, keys, g.expireTime, g.GetGroupMemberIndex, func(ctx context.Context) ([]*relationTb.GroupMemberModel, error) {
+		return g.groupMemberDB.Find(ctx, []string{groupID}, userIDs, nil)
+	})
+}
+
+func (g *GroupCacheRedis) GetGroupMembersPage(ctx context.Context, groupID string, userIDs []string, showNumber, pageNumber int32) (total uint32, groupMembers []*relationTb.GroupMemberModel, err error) {
+	groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
+	if err != nil {
+		return 0, nil, err
+	}
+	if userIDs != nil {
+		userIDs = utils.BothExist(userIDs, groupMemberIDs)
+	} else {
+		userIDs = groupMemberIDs
+	}
+	groupMembers, err = g.GetGroupMembersInfo(ctx, groupID, utils.Paginate(userIDs, int(showNumber), int(showNumber)))
+	return uint32(len(userIDs)), groupMembers, err
+}
+
+func (g *GroupCacheRedis) GetAllGroupMembersInfo(ctx context.Context, groupID string) (groupMembers []*relationTb.GroupMemberModel, err error) {
+	groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	return g.GetGroupMembersInfo(ctx, groupID, groupMemberIDs)
+}
+
+func (g *GroupCacheRedis) GetAllGroupMemberInfo(ctx context.Context, groupID string) ([]*relationTb.GroupMemberModel, error) {
+	groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	var keys []string
+	for _, groupMemberID := range groupMemberIDs {
+		keys = append(keys, g.getGroupMemberInfoKey(groupID, groupMemberID))
+	}
+	return batchGetCache(ctx, g.rcClient, keys, g.expireTime, g.GetGroupMemberIndex, func(ctx context.Context) ([]*relationTb.GroupMemberModel, error) {
+		return g.groupMemberDB.Find(ctx, []string{groupID}, groupMemberIDs, nil)
+	})
+}
+
+func (g *GroupCacheRedis) DelGroupMembersInfo(groupID string, userIDs ...string) GroupCache {
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, g.getGroupMemberInfoKey(groupID, userID))
+	}
+	cache := g.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}
+
+func (g *GroupCacheRedis) GetGroupMemberNum(ctx context.Context, groupID string) (memberNum int64, err error) {
+	return getCache(ctx, g.rcClient, g.getGroupMemberNumKey(groupID), g.expireTime, func(ctx context.Context) (int64, error) {
+		return g.groupMemberDB.TakeGroupMemberNum(ctx, groupID)
+	})
+}
+
+func (g *GroupCacheRedis) DelGroupsMemberNum(groupID ...string) GroupCache {
+	var keys []string
+	for _, groupID := range groupID {
+		keys = append(keys, g.getGroupMemberNumKey(groupID))
+	}
+	cache := g.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}

pkg/common/db/cache/init_redis.go

@@ -0,0 +1,44 @@
+package cache
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mw/specialerror"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/redis/go-redis/v9"
+)
+
+func NewRedis() (redis.UniversalClient, error) {
+	if len(config.Config.Redis.Address) == 0 {
+		return nil, errors.New("redis address is empty")
+	}
+	specialerror.AddReplace(redis.Nil, errs.ErrRecordNotFound)
+	var rdb redis.UniversalClient
+	if len(config.Config.Redis.Address) > 1 {
+		rdb = redis.NewClusterClient(&redis.ClusterOptions{
+			Addrs:    config.Config.Redis.Address,
+			Username: config.Config.Redis.Username,
+			Password: config.Config.Redis.Password, // no password set
+			PoolSize: 50,
+		})
+	} else {
+		rdb = redis.NewClient(&redis.Options{
+			Addr:     config.Config.Redis.Address[0],
+			Username: config.Config.Redis.Username,
+			Password: config.Config.Redis.Password, // no password set
+			DB:       0,                            // use default DB
+			PoolSize: 100,                          // 连接池大小
+		})
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+	defer cancel()
+	err := rdb.Ping(ctx).Err()
+	if err != nil {
+		return nil, fmt.Errorf("redis ping %w", err)
+	}
+	return rdb, nil
+}

pkg/common/db/cache/meta_cache.go

@@ -0,0 +1,191 @@
+package cache
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/dtm-labs/rockscache"
+)
+
+const (
+	scanCount     = 3000
+	maxRetryTimes = 5
+	retryInterval = time.Millisecond * 100
+)
+
+var errIndex = errors.New("err index")
+
+type metaCache interface {
+	ExecDel(ctx context.Context) error
+	// delete key rapid
+	DelKey(ctx context.Context, key string) error
+	AddKeys(keys ...string)
+	ClearKeys()
+	GetPreDelKeys() []string
+}
+
+func NewMetaCacheRedis(rcClient *rockscache.Client, keys ...string) metaCache {
+	return &metaCacheRedis{rcClient: rcClient, keys: keys, maxRetryTimes: maxRetryTimes, retryInterval: retryInterval}
+}
+
+type metaCacheRedis struct {
+	rcClient      *rockscache.Client
+	keys          []string
+	maxRetryTimes int
+	retryInterval time.Duration
+}
+
+func (m *metaCacheRedis) ExecDel(ctx context.Context) error {
+	if len(m.keys) > 0 {
+		log.ZDebug(ctx, "delete cache", "keys", m.keys)
+		retryTimes := 0
+		for {
+			if err := m.rcClient.TagAsDeletedBatch2(ctx, m.keys); err != nil {
+				if retryTimes >= m.maxRetryTimes {
+					err = errs.ErrInternalServer.Wrap(fmt.Sprintf("delete cache error: %v, keys: %v, retry times %d, please check redis server", err, m.keys, retryTimes))
+					log.ZWarn(ctx, "delete cache failed, please handle keys", err, "keys", m.keys)
+					return err
+				}
+				retryTimes++
+			} else {
+				break
+			}
+		}
+	}
+	return nil
+}
+
+func (m *metaCacheRedis) DelKey(ctx context.Context, key string) error {
+	return m.rcClient.TagAsDeleted2(ctx, key)
+}
+
+func (m *metaCacheRedis) AddKeys(keys ...string) {
+	m.keys = append(m.keys, keys...)
+}
+
+func (m *metaCacheRedis) ClearKeys() {
+	m.keys = []string{}
+}
+
+func (m *metaCacheRedis) GetPreDelKeys() []string {
+	return m.keys
+}
+
+func GetDefaultOpt() rockscache.Options {
+	opts := rockscache.NewDefaultOptions()
+	opts.StrongConsistency = true
+	opts.RandomExpireAdjustment = 0.2
+	return opts
+}
+
+func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key string, expire time.Duration, fn func(ctx context.Context) (T, error)) (T, error) {
+	var t T
+	var write bool
+	v, err := rcClient.Fetch2(ctx, key, expire, func() (s string, err error) {
+		t, err = fn(ctx)
+		if err != nil {
+			return "", err
+		}
+		bs, err := json.Marshal(t)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		write = true
+		return string(bs), nil
+	})
+	if err != nil {
+		return t, err
+	}
+	if write {
+		return t, nil
+	}
+	if v == "" {
+		return t, errs.ErrRecordNotFound.Wrap("cache is not found")
+	}
+	err = json.Unmarshal([]byte(v), &t)
+	if err != nil {
+		log.ZError(ctx, "cache json.Unmarshal failed", err, "key", key, "value", v, "expire", expire)
+		return t, utils.Wrap(err, "")
+	}
+	return t, nil
+}
+
+func batchGetCache[T any](ctx context.Context, rcClient *rockscache.Client, keys []string, expire time.Duration, keyIndexFn func(t T, keys []string) (int, error), fn func(ctx context.Context) ([]T, error)) ([]T, error) {
+	batchMap, err := rcClient.FetchBatch2(ctx, keys, expire, func(idxs []int) (m map[int]string, err error) {
+		values := make(map[int]string)
+		tArrays, err := fn(ctx)
+		if err != nil {
+			return nil, err
+		}
+		for _, v := range tArrays {
+			index, err := keyIndexFn(v, keys)
+			if err != nil {
+				continue
+			}
+			bs, err := json.Marshal(v)
+			if err != nil {
+				return nil, utils.Wrap(err, "marshal failed")
+			}
+			values[index] = string(bs)
+		}
+		return values, nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	var tArrays []T
+	for _, v := range batchMap {
+		if v != "" {
+			var t T
+			err = json.Unmarshal([]byte(v), &t)
+			if err != nil {
+				return nil, utils.Wrap(err, "unmarshal failed")
+			}
+			tArrays = append(tArrays, t)
+		}
+	}
+	return tArrays, nil
+}
+
+func batchGetCacheMap[T any](ctx context.Context, rcClient *rockscache.Client, keys, originKeys []string, expire time.Duration, keyIndexFn func(s string, keys []string) (int, error), fn func(ctx context.Context) (map[string]T, error)) (map[string]T, error) {
+	batchMap, err := rcClient.FetchBatch2(ctx, keys, expire, func(idxs []int) (m map[int]string, err error) {
+		tArrays, err := fn(ctx)
+		if err != nil {
+			return nil, err
+		}
+		values := make(map[int]string)
+		for k, v := range tArrays {
+			index, err := keyIndexFn(k, originKeys)
+			if err != nil {
+				continue
+			}
+			bs, err := json.Marshal(v)
+			if err != nil {
+				return nil, utils.Wrap(err, "marshal failed")
+			}
+			values[index] = string(bs)
+		}
+		return values, nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	tMap := make(map[string]T)
+	for i, v := range batchMap {
+		if v != "" {
+			var t T
+			err = json.Unmarshal([]byte(v), &t)
+			if err != nil {
+				return nil, utils.Wrap(err, "unmarshal failed")
+			}
+			tMap[originKeys[i]] = t
+		}
+	}
+	return tMap, nil
+}

pkg/common/db/cache/msg.go

@@ -0,0 +1,577 @@
+package cache
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/dtm-labs/rockscache"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	unRelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/gogo/protobuf/jsonpb"
+
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	maxSeq                 = "MAX_SEQ:"
+	minSeq                 = "MIN_SEQ:"
+	conversationUserMinSeq = "CON_USER_MIN_SEQ:"
+	hasReadSeq             = "HAS_READ_SEQ:"
+
+	appleDeviceToken = "DEVICE_TOKEN"
+	getuiToken       = "GETUI_TOKEN"
+	getuiTaskID      = "GETUI_TASK_ID"
+	signalCache      = "SIGNAL_CACHE:"
+	signalListCache  = "SIGNAL_LIST_CACHE:"
+	fcmToken         = "FCM_TOKEN:"
+
+	messageCache            = "MESSAGE_CACHE:"
+	messageDelUserList      = "MESSAGE_DEL_USER_LIST:"
+	userDelMessagesList     = "USER_DEL_MESSAGES_LIST:"
+	sendMsgFailedFlag       = "SEND_MSG_FAILED_FLAG:"
+	userBadgeUnreadCountSum = "USER_BADGE_UNREAD_COUNT_SUM:"
+	exTypeKeyLocker         = "EX_LOCK:"
+	uidPidToken             = "UID_PID_TOKEN_STATUS:"
+)
+
+type SeqCache interface {
+	SetMaxSeq(ctx context.Context, conversationID string, maxSeq int64) error
+	GetMaxSeqs(ctx context.Context, conversationIDs []string) (map[string]int64, error)
+	GetMaxSeq(ctx context.Context, conversationID string) (int64, error)
+	SetMinSeq(ctx context.Context, conversationID string, minSeq int64) error
+	SetMinSeqs(ctx context.Context, seqs map[string]int64) error
+	GetMinSeqs(ctx context.Context, conversationIDs []string) (map[string]int64, error)
+	GetMinSeq(ctx context.Context, conversationID string) (int64, error)
+	GetConversationUserMinSeq(ctx context.Context, conversationID string, userID string) (int64, error)
+	GetConversationUserMinSeqs(ctx context.Context, conversationID string, userIDs []string) (map[string]int64, error)
+	SetConversationUserMinSeq(ctx context.Context, conversationID string, userID string, minSeq int64) error
+	// seqs map: key userID value minSeq
+	SetConversationUserMinSeqs(ctx context.Context, conversationID string, seqs map[string]int64) (err error)
+	// seqs map: key conversationID value minSeq
+	SetUserConversationsMinSeqs(ctx context.Context, userID string, seqs map[string]int64) error
+	// has read seq
+	SetHasReadSeq(ctx context.Context, userID string, conversationID string, hasReadSeq int64) error
+	// k: user, v: seq
+	SetHasReadSeqs(ctx context.Context, conversationID string, hasReadSeqs map[string]int64) error
+	// k: conversation, v :seq
+	UserSetHasReadSeqs(ctx context.Context, userID string, hasReadSeqs map[string]int64) error
+	GetHasReadSeqs(ctx context.Context, userID string, conversationIDs []string) (map[string]int64, error)
+	GetHasReadSeq(ctx context.Context, userID string, conversationID string) (int64, error)
+}
+
+type thirdCache interface {
+	SetFcmToken(ctx context.Context, account string, platformID int, fcmToken string, expireTime int64) (err error)
+	GetFcmToken(ctx context.Context, account string, platformID int) (string, error)
+	DelFcmToken(ctx context.Context, account string, platformID int) error
+	IncrUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error)
+	SetUserBadgeUnreadCountSum(ctx context.Context, userID string, value int) error
+	GetUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error)
+	SetGetuiToken(ctx context.Context, token string, expireTime int64) error
+	GetGetuiToken(ctx context.Context) (string, error)
+	SetGetuiTaskID(ctx context.Context, taskID string, expireTime int64) error
+	GetGetuiTaskID(ctx context.Context) (string, error)
+}
+
+type MsgModel interface {
+	SeqCache
+	thirdCache
+	AddTokenFlag(ctx context.Context, userID string, platformID int, token string, flag int) error
+	GetTokensWithoutError(ctx context.Context, userID string, platformID int) (map[string]int, error)
+	SetTokenMapByUidPid(ctx context.Context, userID string, platformID int, m map[string]int) error
+	DeleteTokenByUidPid(ctx context.Context, userID string, platformID int, fields []string) error
+	GetMessagesBySeq(ctx context.Context, conversationID string, seqs []int64) (seqMsg []*sdkws.MsgData, failedSeqList []int64, err error)
+	SetMessageToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error)
+	UserDeleteMsgs(ctx context.Context, conversationID string, seqs []int64, userID string) error
+	DelUserDeleteMsgsList(ctx context.Context, conversationID string, seqs []int64)
+	DeleteMessages(ctx context.Context, conversationID string, seqs []int64) error
+	GetUserDelList(ctx context.Context, userID, conversationID string) (seqs []int64, err error)
+	CleanUpOneConversationAllMsg(ctx context.Context, conversationID string) error
+	DelMsgFromCache(ctx context.Context, userID string, seqList []int64) error
+	SetSendMsgStatus(ctx context.Context, id string, status int32) error
+	GetSendMsgStatus(ctx context.Context, id string) (int32, error)
+	JudgeMessageReactionExist(ctx context.Context, clientMsgID string, sessionType int32) (bool, error)
+	GetOneMessageAllReactionList(ctx context.Context, clientMsgID string, sessionType int32) (map[string]string, error)
+	DeleteOneMessageKey(ctx context.Context, clientMsgID string, sessionType int32, subKey string) error
+	SetMessageReactionExpire(ctx context.Context, clientMsgID string, sessionType int32, expiration time.Duration) (bool, error)
+	GetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey string) (string, error)
+	SetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey, value string) error
+	LockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error
+	UnLockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error
+}
+
+func NewMsgCacheModel(client redis.UniversalClient) MsgModel {
+	return &msgCache{rdb: client}
+}
+
+type msgCache struct {
+	metaCache
+	rdb            redis.UniversalClient
+	expireTime     time.Duration
+	rcClient       *rockscache.Client
+	msgDocDatabase unRelationTb.MsgDocModelInterface
+}
+
+func (c *msgCache) getMaxSeqKey(conversationID string) string {
+	return maxSeq + conversationID
+}
+
+func (c *msgCache) getMinSeqKey(conversationID string) string {
+	return minSeq + conversationID
+}
+
+func (c *msgCache) getHasReadSeqKey(conversationID string, userID string) string {
+	return hasReadSeq + userID + ":" + conversationID
+}
+
+func (c *msgCache) setSeq(ctx context.Context, conversationID string, seq int64, getkey func(conversationID string) string) error {
+	return utils.Wrap1(c.rdb.Set(ctx, getkey(conversationID), seq, 0).Err())
+}
+
+func (c *msgCache) getSeq(ctx context.Context, conversationID string, getkey func(conversationID string) string) (int64, error) {
+	return utils.Wrap2(c.rdb.Get(ctx, getkey(conversationID)).Int64())
+}
+
+func (c *msgCache) getSeqs(ctx context.Context, items []string, getkey func(s string) string) (m map[string]int64, err error) {
+	pipe := c.rdb.Pipeline()
+	for _, v := range items {
+		if err := pipe.Get(ctx, getkey(v)).Err(); err != nil && err != redis.Nil {
+			return nil, errs.Wrap(err)
+		}
+	}
+	result, err := pipe.Exec(ctx)
+	if err != nil && err != redis.Nil {
+		return nil, errs.Wrap(err)
+	}
+	m = make(map[string]int64, len(items))
+	for i, v := range result {
+		seq := v.(*redis.StringCmd)
+		if seq.Err() != nil && seq.Err() != redis.Nil {
+			return nil, errs.Wrap(v.Err())
+		}
+		val := utils.StringToInt64(seq.Val())
+		if val != 0 {
+			m[items[i]] = val
+		}
+	}
+	return m, nil
+}
+
+func (c *msgCache) SetMaxSeq(ctx context.Context, conversationID string, maxSeq int64) error {
+	return c.setSeq(ctx, conversationID, maxSeq, c.getMaxSeqKey)
+}
+
+func (c *msgCache) GetMaxSeqs(ctx context.Context, conversationIDs []string) (m map[string]int64, err error) {
+	return c.getSeqs(ctx, conversationIDs, c.getMaxSeqKey)
+}
+
+func (c *msgCache) GetMaxSeq(ctx context.Context, conversationID string) (int64, error) {
+	return c.getSeq(ctx, conversationID, c.getMaxSeqKey)
+}
+func (c *msgCache) SetMinSeq(ctx context.Context, conversationID string, minSeq int64) error {
+	return c.setSeq(ctx, conversationID, minSeq, c.getMinSeqKey)
+}
+
+func (c *msgCache) setSeqs(ctx context.Context, seqs map[string]int64, getkey func(key string) string) error {
+	pipe := c.rdb.Pipeline()
+	for k, seq := range seqs {
+		err := pipe.Set(ctx, getkey(k), seq, 0).Err()
+		if err != nil {
+			return errs.Wrap(err)
+		}
+	}
+	_, err := pipe.Exec(ctx)
+	return err
+}
+
+func (c *msgCache) SetMinSeqs(ctx context.Context, seqs map[string]int64) error {
+	return c.setSeqs(ctx, seqs, c.getMinSeqKey)
+}
+
+func (c *msgCache) GetMinSeqs(ctx context.Context, conversationIDs []string) (map[string]int64, error) {
+	return c.getSeqs(ctx, conversationIDs, c.getMinSeqKey)
+}
+func (c *msgCache) GetMinSeq(ctx context.Context, conversationID string) (int64, error) {
+	return c.getSeq(ctx, conversationID, c.getMinSeqKey)
+}
+
+func (c *msgCache) getConversationUserMinSeqKey(conversationID, userID string) string {
+	return conversationUserMinSeq + conversationID + "u:" + userID
+}
+
+func (c *msgCache) GetConversationUserMinSeq(ctx context.Context, conversationID string, userID string) (int64, error) {
+	return utils.Wrap2(c.rdb.Get(ctx, c.getConversationUserMinSeqKey(conversationID, userID)).Int64())
+}
+
+func (c *msgCache) GetConversationUserMinSeqs(ctx context.Context, conversationID string, userIDs []string) (m map[string]int64, err error) {
+	return c.getSeqs(ctx, userIDs, func(userID string) string {
+		return c.getConversationUserMinSeqKey(conversationID, userID)
+	})
+}
+func (c *msgCache) SetConversationUserMinSeq(ctx context.Context, conversationID string, userID string, minSeq int64) error {
+	return utils.Wrap1(c.rdb.Set(ctx, c.getConversationUserMinSeqKey(conversationID, userID), minSeq, 0).Err())
+}
+
+func (c *msgCache) SetConversationUserMinSeqs(ctx context.Context, conversationID string, seqs map[string]int64) (err error) {
+	return c.setSeqs(ctx, seqs, func(userID string) string {
+		return c.getConversationUserMinSeqKey(conversationID, userID)
+	})
+}
+
+func (c *msgCache) SetUserConversationsMinSeqs(ctx context.Context, userID string, seqs map[string]int64) (err error) {
+	return c.setSeqs(ctx, seqs, func(conversationID string) string {
+		return c.getConversationUserMinSeqKey(conversationID, userID)
+	})
+}
+
+func (c *msgCache) SetHasReadSeq(ctx context.Context, userID string, conversationID string, hasReadSeq int64) error {
+	return utils.Wrap1(c.rdb.Set(ctx, c.getHasReadSeqKey(conversationID, userID), hasReadSeq, 0).Err())
+}
+
+func (c *msgCache) SetHasReadSeqs(ctx context.Context, conversationID string, hasReadSeqs map[string]int64) error {
+	return c.setSeqs(ctx, hasReadSeqs, func(userID string) string {
+		return c.getHasReadSeqKey(conversationID, userID)
+	})
+}
+
+func (c *msgCache) UserSetHasReadSeqs(ctx context.Context, userID string, hasReadSeqs map[string]int64) error {
+	return c.setSeqs(ctx, hasReadSeqs, func(conversationID string) string {
+		return c.getHasReadSeqKey(conversationID, userID)
+	})
+}
+
+func (c *msgCache) GetHasReadSeqs(ctx context.Context, userID string, conversationIDs []string) (map[string]int64, error) {
+	return c.getSeqs(ctx, conversationIDs, func(conversationID string) string {
+		return c.getHasReadSeqKey(conversationID, userID)
+	})
+}
+
+func (c *msgCache) GetHasReadSeq(ctx context.Context, userID string, conversationID string) (int64, error) {
+	return utils.Wrap2(c.rdb.Get(ctx, c.getHasReadSeqKey(conversationID, userID)).Int64())
+}
+
+func (c *msgCache) AddTokenFlag(ctx context.Context, userID string, platformID int, token string, flag int) error {
+	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
+	return errs.Wrap(c.rdb.HSet(ctx, key, token, flag).Err())
+}
+
+func (c *msgCache) GetTokensWithoutError(ctx context.Context, userID string, platformID int) (map[string]int, error) {
+	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
+	m, err := c.rdb.HGetAll(ctx, key).Result()
+	if err != nil {
+		return nil, errs.Wrap(err)
+	}
+	mm := make(map[string]int)
+	for k, v := range m {
+		mm[k] = utils.StringToInt(v)
+	}
+	return mm, nil
+}
+
+func (c *msgCache) SetTokenMapByUidPid(ctx context.Context, userID string, platform int, m map[string]int) error {
+	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platform)
+	mm := make(map[string]interface{})
+	for k, v := range m {
+		mm[k] = v
+	}
+	return errs.Wrap(c.rdb.HSet(ctx, key, mm).Err())
+}
+
+func (c *msgCache) DeleteTokenByUidPid(ctx context.Context, userID string, platform int, fields []string) error {
+	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platform)
+	return errs.Wrap(c.rdb.HDel(ctx, key, fields...).Err())
+}
+
+func (c *msgCache) getMessageCacheKey(conversationID string, seq int64) string {
+	return messageCache + conversationID + "_" + strconv.Itoa(int(seq))
+}
+
+func (c *msgCache) allMessageCacheKey(conversationID string) string {
+	return messageCache + conversationID + "_*"
+}
+
+func (c *msgCache) GetMessagesBySeq(ctx context.Context, conversationID string, seqs []int64) (seqMsgs []*sdkws.MsgData, failedSeqs []int64, err error) {
+	pipe := c.rdb.Pipeline()
+	for _, v := range seqs {
+		//MESSAGE_CACHE:169.254.225.224_reliability1653387820_0_1
+		key := c.getMessageCacheKey(conversationID, v)
+		if err := pipe.Get(ctx, key).Err(); err != nil && err != redis.Nil {
+			return nil, nil, err
+		}
+	}
+	result, err := pipe.Exec(ctx)
+	for i, v := range result {
+		cmd := v.(*redis.StringCmd)
+		if cmd.Err() != nil {
+			failedSeqs = append(failedSeqs, seqs[i])
+		} else {
+			msg := sdkws.MsgData{}
+			err = utils.String2Pb(cmd.Val(), &msg)
+			if err == nil {
+				if msg.Status != constant.MsgDeleted {
+					seqMsgs = append(seqMsgs, &msg)
+					continue
+				}
+			} else {
+				log.ZWarn(ctx, "UnmarshalString failed", err, "conversationID", conversationID, "seq", seqs[i], "msg", cmd.Val())
+			}
+			failedSeqs = append(failedSeqs, seqs[i])
+		}
+	}
+	return seqMsgs, failedSeqs, err
+}
+
+func (c *msgCache) SetMessageToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error) {
+	pipe := c.rdb.Pipeline()
+	var failedMsgs []*sdkws.MsgData
+	for _, msg := range msgs {
+		key := c.getMessageCacheKey(conversationID, msg.Seq)
+		s, err := utils.Pb2String(msg)
+		if err != nil {
+			return 0, errs.Wrap(err)
+		}
+		err = pipe.Set(ctx, key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err()
+		if err != nil {
+			failedMsgs = append(failedMsgs, msg)
+			log.ZWarn(ctx, "set msg 2 cache failed", err, "msg", failedMsgs)
+		}
+	}
+	_, err := pipe.Exec(ctx)
+	return len(failedMsgs), err
+}
+
+func (c *msgCache) getMessageDelUserListKey(conversationID string, seq int64) string {
+	return messageDelUserList + conversationID + ":" + strconv.Itoa(int(seq))
+}
+
+func (c *msgCache) getUserDelList(conversationID, userID string) string {
+	return userDelMessagesList + conversationID + ":" + userID
+}
+
+func (c *msgCache) UserDeleteMsgs(ctx context.Context, conversationID string, seqs []int64, userID string) error {
+	pipe := c.rdb.Pipeline()
+	for _, seq := range seqs {
+		delUserListKey := c.getMessageDelUserListKey(conversationID, seq)
+		userDelListKey := c.getUserDelList(conversationID, userID)
+		err := pipe.SAdd(ctx, delUserListKey, userID).Err()
+		if err != nil {
+			return errs.Wrap(err)
+		}
+		err = pipe.SAdd(ctx, userDelListKey, seq).Err()
+		if err != nil {
+			return errs.Wrap(err)
+		}
+		if err := pipe.Expire(ctx, delUserListKey, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+			return errs.Wrap(err)
+		}
+		if err := pipe.Expire(ctx, userDelListKey, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+			return errs.Wrap(err)
+		}
+	}
+	_, err := pipe.Exec(ctx)
+	return errs.Wrap(err)
+}
+
+func (c *msgCache) GetUserDelList(ctx context.Context, userID, conversationID string) (seqs []int64, err error) {
+	result, err := c.rdb.SMembers(ctx, c.getUserDelList(conversationID, userID)).Result()
+	if err != nil {
+		return nil, errs.Wrap(err)
+	}
+	seqs = make([]int64, len(result))
+	for i, v := range result {
+		seqs[i] = utils.StringToInt64(v)
+	}
+	return seqs, nil
+}
+
+func (c *msgCache) DelUserDeleteMsgsList(ctx context.Context, conversationID string, seqs []int64) {
+	for _, seq := range seqs {
+		delUsers, err := c.rdb.SMembers(ctx, c.getMessageDelUserListKey(conversationID, seq)).Result()
+		if err != nil {
+			log.ZWarn(ctx, "DelUserDeleteMsgsList failed", err, "conversationID", conversationID, "seq", seq)
+			continue
+		}
+		if len(delUsers) > 0 {
+			pipe := c.rdb.Pipeline()
+			var failedFlag bool
+			for _, userID := range delUsers {
+				err = pipe.SRem(ctx, c.getUserDelList(conversationID, userID), seq).Err()
+				if err != nil {
+					failedFlag = true
+					log.ZWarn(ctx, "DelUserDeleteMsgsList failed", err, "conversationID", conversationID, "seq", seq, "userID", userID)
+				}
+			}
+			if !failedFlag {
+				if err := pipe.Del(ctx, c.getMessageDelUserListKey(conversationID, seq)).Err(); err != nil {
+					log.ZWarn(ctx, "DelUserDeleteMsgsList failed", err, "conversationID", conversationID, "seq", seq)
+				}
+			}
+			if _, err := pipe.Exec(ctx); err != nil {
+				log.ZError(ctx, "pipe exec failed", err, "conversationID", conversationID, "seq", seq)
+			}
+		}
+	}
+}
+
+func (c *msgCache) DeleteMessages(ctx context.Context, conversationID string, seqs []int64) error {
+	pipe := c.rdb.Pipeline()
+	for _, seq := range seqs {
+		if err := pipe.Del(ctx, c.getMessageCacheKey(conversationID, seq)).Err(); err != nil {
+			return errs.Wrap(err)
+		}
+	}
+	_, err := pipe.Exec(ctx)
+	return errs.Wrap(err)
+}
+
+func (c *msgCache) CleanUpOneConversationAllMsg(ctx context.Context, conversationID string) error {
+	vals, err := c.rdb.Keys(ctx, c.allMessageCacheKey(conversationID)).Result()
+	if err == redis.Nil {
+		return nil
+	}
+	if err != nil {
+		return errs.Wrap(err)
+	}
+	pipe := c.rdb.Pipeline()
+	for _, v := range vals {
+		if err := pipe.Del(ctx, v).Err(); err != nil {
+			return errs.Wrap(err)
+		}
+	}
+	_, err = pipe.Exec(ctx)
+	return errs.Wrap(err)
+}
+
+func (c *msgCache) DelMsgFromCache(ctx context.Context, userID string, seqs []int64) error {
+	for _, seq := range seqs {
+		key := c.getMessageCacheKey(userID, seq)
+		result, err := c.rdb.Get(ctx, key).Result()
+		if err != nil {
+			if err == redis.Nil {
+				continue
+			}
+			return errs.Wrap(err)
+		}
+		var msg sdkws.MsgData
+		if err := jsonpb.UnmarshalString(result, &msg); err != nil {
+			return err
+		}
+		msg.Status = constant.MsgDeleted
+		s, err := utils.Pb2String(&msg)
+		if err != nil {
+			return errs.Wrap(err)
+		}
+		if err := c.rdb.Set(ctx, key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+			return errs.Wrap(err)
+		}
+	}
+	return nil
+}
+
+func (c *msgCache) SetGetuiToken(ctx context.Context, token string, expireTime int64) error {
+	return errs.Wrap(c.rdb.Set(ctx, getuiToken, token, time.Duration(expireTime)*time.Second).Err())
+}
+
+func (c *msgCache) GetGetuiToken(ctx context.Context) (string, error) {
+	return utils.Wrap2(c.rdb.Get(ctx, getuiToken).Result())
+}
+
+func (c *msgCache) SetGetuiTaskID(ctx context.Context, taskID string, expireTime int64) error {
+	return errs.Wrap(c.rdb.Set(ctx, getuiTaskID, taskID, time.Duration(expireTime)*time.Second).Err())
+}
+
+func (c *msgCache) GetGetuiTaskID(ctx context.Context) (string, error) {
+	return utils.Wrap2(c.rdb.Get(ctx, getuiTaskID).Result())
+}
+
+func (c *msgCache) SetSendMsgStatus(ctx context.Context, id string, status int32) error {
+	return errs.Wrap(c.rdb.Set(ctx, sendMsgFailedFlag+id, status, time.Hour*24).Err())
+}
+
+func (c *msgCache) GetSendMsgStatus(ctx context.Context, id string) (int32, error) {
+	result, err := c.rdb.Get(ctx, sendMsgFailedFlag+id).Int()
+	return int32(result), errs.Wrap(err)
+}
+
+func (c *msgCache) SetFcmToken(ctx context.Context, account string, platformID int, fcmToken string, expireTime int64) (err error) {
+	return errs.Wrap(c.rdb.Set(ctx, fcmToken+account+":"+strconv.Itoa(platformID), fcmToken, time.Duration(expireTime)*time.Second).Err())
+}
+
+func (c *msgCache) GetFcmToken(ctx context.Context, account string, platformID int) (string, error) {
+	return utils.Wrap2(c.rdb.Get(ctx, fcmToken+account+":"+strconv.Itoa(platformID)).Result())
+}
+
+func (c *msgCache) DelFcmToken(ctx context.Context, account string, platformID int) error {
+	return errs.Wrap(c.rdb.Del(ctx, fcmToken+account+":"+strconv.Itoa(platformID)).Err())
+}
+
+func (c *msgCache) IncrUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error) {
+	seq, err := c.rdb.Incr(ctx, userBadgeUnreadCountSum+userID).Result()
+	return int(seq), errs.Wrap(err)
+}
+
+func (c *msgCache) SetUserBadgeUnreadCountSum(ctx context.Context, userID string, value int) error {
+	return errs.Wrap(c.rdb.Set(ctx, userBadgeUnreadCountSum+userID, value, 0).Err())
+}
+
+func (c *msgCache) GetUserBadgeUnreadCountSum(ctx context.Context, userID string) (int, error) {
+	return utils.Wrap2(c.rdb.Get(ctx, userBadgeUnreadCountSum+userID).Int())
+}
+
+func (c *msgCache) LockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error {
+	key := exTypeKeyLocker + clientMsgID + "_" + TypeKey
+	return errs.Wrap(c.rdb.SetNX(ctx, key, 1, time.Minute).Err())
+}
+
+func (c *msgCache) UnLockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error {
+	key := exTypeKeyLocker + clientMsgID + "_" + TypeKey
+	return errs.Wrap(c.rdb.Del(ctx, key).Err())
+}
+
+func (c *msgCache) getMessageReactionExPrefix(clientMsgID string, sessionType int32) string {
+	switch sessionType {
+	case constant.SingleChatType:
+		return "EX_SINGLE_" + clientMsgID
+	case constant.GroupChatType:
+		return "EX_GROUP_" + clientMsgID
+	case constant.SuperGroupChatType:
+		return "EX_SUPER_GROUP_" + clientMsgID
+	case constant.NotificationChatType:
+		return "EX_NOTIFICATION" + clientMsgID
+	}
+	return ""
+}
+
+func (c *msgCache) JudgeMessageReactionExist(ctx context.Context, clientMsgID string, sessionType int32) (bool, error) {
+	n, err := c.rdb.Exists(ctx, c.getMessageReactionExPrefix(clientMsgID, sessionType)).Result()
+	if err != nil {
+		return false, utils.Wrap(err, "")
+	}
+	return n > 0, nil
+}
+
+func (c *msgCache) SetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey, value string) error {
+	return errs.Wrap(c.rdb.HSet(ctx, c.getMessageReactionExPrefix(clientMsgID, sessionType), typeKey, value).Err())
+}
+
+func (c *msgCache) SetMessageReactionExpire(ctx context.Context, clientMsgID string, sessionType int32, expiration time.Duration) (bool, error) {
+	return utils.Wrap2(c.rdb.Expire(ctx, c.getMessageReactionExPrefix(clientMsgID, sessionType), expiration).Result())
+}
+
+func (c *msgCache) GetMessageTypeKeyValue(ctx context.Context, clientMsgID string, sessionType int32, typeKey string) (string, error) {
+	return utils.Wrap2(c.rdb.HGet(ctx, c.getMessageReactionExPrefix(clientMsgID, sessionType), typeKey).Result())
+}
+
+func (c *msgCache) GetOneMessageAllReactionList(ctx context.Context, clientMsgID string, sessionType int32) (map[string]string, error) {
+	return utils.Wrap2(c.rdb.HGetAll(ctx, c.getMessageReactionExPrefix(clientMsgID, sessionType)).Result())
+}
+
+func (c *msgCache) DeleteOneMessageKey(ctx context.Context, clientMsgID string, sessionType int32, subKey string) error {
+	return errs.Wrap(c.rdb.HDel(ctx, c.getMessageReactionExPrefix(clientMsgID, sessionType), subKey).Err())
+}

pkg/common/db/cache/user.go

@@ -0,0 +1,109 @@
+package cache
+
+import (
+	"context"
+	"time"
+
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/dtm-labs/rockscache"
+	"github.com/redis/go-redis/v9"
+)
+
+const (
+	userExpireTime          = time.Second * 60 * 60 * 12
+	userInfoKey             = "USER_INFO:"
+	userGlobalRecvMsgOptKey = "USER_GLOBAL_RECV_MSG_OPT_KEY:"
+)
+
+type UserCache interface {
+	metaCache
+	NewCache() UserCache
+	GetUserInfo(ctx context.Context, userID string) (userInfo *relationTb.UserModel, err error)
+	GetUsersInfo(ctx context.Context, userIDs []string) ([]*relationTb.UserModel, error)
+	DelUsersInfo(userIDs ...string) UserCache
+	GetUserGlobalRecvMsgOpt(ctx context.Context, userID string) (opt int, err error)
+	DelUsersGlobalRecvMsgOpt(userIDs ...string) UserCache
+}
+
+type UserCacheRedis struct {
+	metaCache
+	userDB     relationTb.UserModelInterface
+	expireTime time.Duration
+	rcClient   *rockscache.Client
+}
+
+func NewUserCacheRedis(rdb redis.UniversalClient, userDB relationTb.UserModelInterface, options rockscache.Options) UserCache {
+	rcClient := rockscache.NewClient(rdb, options)
+	return &UserCacheRedis{
+		metaCache:  NewMetaCacheRedis(rcClient),
+		userDB:     userDB,
+		expireTime: userExpireTime,
+		rcClient:   rcClient,
+	}
+}
+
+func (u *UserCacheRedis) NewCache() UserCache {
+	return &UserCacheRedis{
+		metaCache:  NewMetaCacheRedis(u.rcClient, u.metaCache.GetPreDelKeys()...),
+		userDB:     u.userDB,
+		expireTime: u.expireTime,
+		rcClient:   u.rcClient,
+	}
+}
+
+func (u *UserCacheRedis) getUserInfoKey(userID string) string {
+	return userInfoKey + userID
+}
+
+func (u *UserCacheRedis) getUserGlobalRecvMsgOptKey(userID string) string {
+	return userGlobalRecvMsgOptKey + userID
+}
+
+func (u *UserCacheRedis) GetUserInfo(ctx context.Context, userID string) (userInfo *relationTb.UserModel, err error) {
+	return getCache(ctx, u.rcClient, u.getUserInfoKey(userID), u.expireTime, func(ctx context.Context) (*relationTb.UserModel, error) {
+		return u.userDB.Take(ctx, userID)
+	})
+}
+
+func (u *UserCacheRedis) GetUsersInfo(ctx context.Context, userIDs []string) ([]*relationTb.UserModel, error) {
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, u.getUserInfoKey(userID))
+	}
+	return batchGetCache(ctx, u.rcClient, keys, u.expireTime, func(user *relationTb.UserModel, keys []string) (int, error) {
+		for i, key := range keys {
+			if key == u.getUserInfoKey(user.UserID) {
+				return i, nil
+			}
+		}
+		return 0, errIndex
+	}, func(ctx context.Context) ([]*relationTb.UserModel, error) {
+		return u.userDB.Find(ctx, userIDs)
+	})
+}
+
+func (u *UserCacheRedis) DelUsersInfo(userIDs ...string) UserCache {
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, u.getUserInfoKey(userID))
+	}
+	cache := u.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}
+
+func (u *UserCacheRedis) GetUserGlobalRecvMsgOpt(ctx context.Context, userID string) (opt int, err error) {
+	return getCache(ctx, u.rcClient, u.getUserGlobalRecvMsgOptKey(userID), u.expireTime, func(ctx context.Context) (int, error) {
+		return u.userDB.GetUserGlobalRecvMsgOpt(ctx, userID)
+	})
+}
+
+func (u *UserCacheRedis) DelUsersGlobalRecvMsgOpt(userIDs ...string) UserCache {
+	var keys []string
+	for _, userID := range userIDs {
+		keys = append(keys, u.getUserGlobalRecvMsgOptKey(userID))
+	}
+	cache := u.NewCache()
+	cache.AddKeys(keys...)
+	return cache
+}