Scut：缓存管理

　　Scut 的缓存管理看起来还是蛮复杂的。

　 redis 本身就有内存缓存+持久化的作用，Scut还是自己封装了一层内存缓存+Redis缓存+持久化。

。

这是一个缩略版本的结构图。

1. 上半部分是通用的缓存池结构，用来存放各类缓存数据。

　　第一层Dictionary是按大类区分：Entity_{0}、Personal_(0)，type.name 等；

　第二层Dictionary则是进一步细分，比如同样一个type下的 type.name +"UserID"；

2. 下半部分则是应用层对缓存的操作器，包含数据取用+操作方法，应用层数据结构要按照一定的规则进行封装，才能直接使用Scut提供的“带数据修改事件”的各类组件。

CacheItemSet 的作用：

Cache 们都会用 CacheItemSet 容器 来装载具体的数据；

        private readonly CacheType _cacheItemType;　　//标记了缓存的类型，不同类型的缓存在从redis加载时key的组装方式，释放缓存的规则都不相同

        private readonly bool _isReadOnly;

        private CachePeriod _period;　　　　　　　　　　//缓存的核心：生命周期　　　　　　　

        private IDataExpired _itemData;              //具体的数据

　　　　 public bool HasChanged { get; private set; }

生命周期如何起作用？HasChanged 如何起作用？

在 CachePool 里的 DisposeCache 接口有统一处理，但没有发现哪里在定期有效调用？

ShareCacheStruct：

        public IEnumerable<T> Take()

        {

            return DataContainer.ToEntityEnumerable(false);

        }

        public IEnumerable<T> ToEntityEnumerable(bool isLoad = false)

        {

            if (isLoad) CheckLoad();

            return Container.GetEnumerable().Select(pari => pari.Value).OfType<CacheItemSet>().Select(itemSet => (T)itemSet.GetItem());

        }

可以知道 ShareCache 从缓存加载数据时，是整块相应类型的数据全部加载出来，适合用来管理配置、处理公有数据。

PersonalCache：

        public IEnumerable<T> Take()

        {

            return DataContainer.ToGroupEnumerable();

        }

        public T Take(params object[] keys)

        {

            string key = AbstractEntity.CreateKeyCode(keys);

            return DataContainer.TakeEntityFromKey(key);

        }

它可以单个或整体进行缓存加载，更适合处理单用户的某类型数据。

ShareEntity 比 BaseEntity 多了一个 API：GetIdentityId() 未来有什么作用再观察。

AbstractEntity：

        /// <summary>

        /// 存储改变的属性集合

        /// </summary>

        private ConcurrentQueue<string> _changePropertys = new ConcurrentQueue<string>();

        /// <summary>

        /// 等待更新属性

        /// </summary>

        private readonly HashSet<string> _waitUpdateList = new HashSet<string>();

这两个属性，表示 abstracEntity 最重要的作用应该是“部分更新修改过的数据”

持续追踪，发现其作用是向数据库写入修改过的数据：

SqlDataSender.cs:

        public bool Send<T>(params T[] dataList) where T : AbstractEntity

        {

            return Send(dataList, GetPropertyValue, GetPostColumns);

        }

那什么时候进行写入修改数据？ AbstractEntity 下的 EntityChangeEvent : IItemChangeEvent 是如何起作用的？

IItemChangeEvent:

        [JsonIgnore]

        public bool IsExpired { get; set; }

        [JsonIgnore]

        public bool IsInCache { get; set; }

        /// <summary>

        /// 是否有变更

        /// </summary>

        public abstract bool HasChanged { get; }

        /// <summary>

        /// 绑定实体类的属性名（表的列名）

        /// </summary>

        internal abstract string PropertyName { get; set; }

        /// <summary>

        /// 当前对象变更事件对象

        /// </summary>

        public abstract CacheItemChangeEvent ItemEvent { get; }

        /// <summary>

        /// 当前对象的子类变更事件对象

        /// </summary>

        public abstract CacheItemChangeEvent ChildrenEvent { get; }

在 AbstractEntity 中，对本身数值进行“修改、删除进行封装的API”，都会调用事件通知 Notify。

AbstractEntity 重载的 Notify API：

        protected override void Notify(object sender, CacheItemEventArgs eventArgs)

        {

            if (_isReadOnly || CheckChnage()) return;

            _hasChanged = true;

            AddChangePropertys(eventArgs.PropertyName);

            PutToChangeKeys(this);

        }

        private void PutToChangeKeys(AbstractEntity entity)

        {

            if (!IsModifying)

            {

                //Auto trigger modify event

                ProfileManager.ChangeEntityByAutoOfMessageQueueTimes(entity.GetType().FullName, entity.GetKeyCode());

                DataSyncQueueManager.Send(entity);

            }

        }

可以看出这个位置并没有真正使用 EntityChangeEvent 机制，而是重写了 Notity()，在修改数据后，直接向底层队列压入修改队列。

巴特西

Scut：缓存管理

最新文章

热门文章