其他分享
首页 > 其他分享> > 企业级自定义表单引擎解决方案(十)--缓存设计2

企业级自定义表单引擎解决方案(十)--缓存设计2

作者:互联网

  新年伊始,万物皆生机,然冠未去,美帝相向,于华夏之子,吾辈当自强。

  这篇文章接上一篇文章,主要介绍缓存的代码实现

后端本地缓存

  之前介绍的将自定义表单数据全部存储到应用程序内存中,任何自定义表单数据更新之后,都刷新内存缓存,分布式部署涉及到缓存同步刷新问题。

  1. 用线程安全的字典ConcurrentDictionary<string, object> CacheDict,存储每一个数据对象集合,比如视图集合、表单集合等,每一次数据变更都清除具体的一个字典项数据
  2. 绝大多数时间都是读取缓存内容,因此这里上的读写锁,读写每一项缓存时,都上自己的读锁,锁的集合存储在ConcurrentDictionary<string, ReaderWriterLock> CacheReaderWriterLockDict变量中,Key与CacheDict的Key相同。
  3. 当检测到缓存通知服务断开时,会将本地所有缓存清空,直接读取原始数据库,用bool IsEnabledLocalCache变量控制。
  4. 当读取缓存时,发现本地缓存没有数据,则调用具体加载数据委托方法,本地没有数据读取时,需要加锁,防止缓存穿透。

具体代码如下:

/// <summary>
    /// 本地缓存容器
    /// </summary>
    public class LocalCacheContainer
    {
        private static ConcurrentDictionary<string, object> CacheDict;
        private static ConcurrentDictionary<string, ReaderWriterLock> CacheReaderWriterLockDict;

        static LocalCacheContainer()
        {
            CacheDict = new ConcurrentDictionary<string, object>();
            CacheReaderWriterLockDict = new ConcurrentDictionary<string, ReaderWriterLock>();
        }

        public static bool IsEnabledLocalCache { get; private set; } = true;

        /// <summary>
        /// 缓存通知断开时调用
        /// </summary>
        /// <param name="isEnabled">是否启用缓存</param>
        internal static void SetLocalCacheIsEnabled(bool isEnabled)
        {
            IsEnabledLocalCache = isEnabled;
            if(!isEnabled)
            {
                ClearAllCache();
            }
        }

        public static object Get(string key, Func<string, object> factory)
        {
            var readerWriterLock = GetReadWriteLock(key);
            readerWriterLock.AcquireReaderLock(5000);

            try
            {
                //return CacheDict.GetOrAdd(key, factory); // 缓存穿透?
                if (CacheDict.ContainsKey(key))
                {
                    return CacheDict.GetOrAdd(key, factory);
                }
                else
                {
                    lock (string.Intern(key))
                    {
                        return CacheDict.GetOrAdd(key, factory);
                    }
                }
            }
            finally
            {
                readerWriterLock.ReleaseReaderLock();
            }
        }

        internal static void ClearCache(string key)
        {
            var readerWriterLock = GetReadWriteLock(key);
            readerWriterLock.AcquireWriterLock(5000);

            try
            {
                object objRemove;
                CacheDict.TryRemove(key, out objRemove);
            }
            finally
            {
                readerWriterLock.ReleaseReaderLock();
            }
        }

        // 清楚所有缓存信息
        private static void ClearAllCache()
        {
            CacheDict.Clear();
            CacheReaderWriterLockDict.Clear();
        }

        private static ReaderWriterLock GetReadWriteLock(string key)
        {
            return CacheReaderWriterLockDict.GetOrAdd(key, k =>
            {
                return new ReaderWriterLock();
            });
        }
    }

缓存变更处理

  1. 主要分为缓存变更通知与接收缓存变更处理,缓存变更只需要通知哪一个Key过期即可。
  2. 接收缓存变更处理比较简单,接收到缓存变更之后,将内存容器中对应的字典项删除即可。
  3. 缓存通知定义为接口,如果是单应用部署,直接调用删除本地缓存服务即可,如果是分布式部署,也会调用删除本地缓存数据,通知发送分布式通知到其他自定义表单应用服务器,其他自定义表单应用服务器接收到缓存变更通知时,删除本地缓存数据。
public static class ReceiveCacheNotice
    {
        public static void ReceiveClearCache(string key)
        {
            LocalCacheContainer.ClearCache(key);
        }

        public static void ReceiveClearCaches(List<string> keys)
        {
            foreach(var key in keys)
            {
                LocalCacheContainer.ClearCache(key);
            }
        }

        public static void SetLocalCacheIsEnabled(bool isEnabled)
        {
            LocalCacheContainer.SetLocalCacheIsEnabled(isEnabled);
        }
    }
    /// <summary>
    /// 设计时实体变更通知缓存
    /// </summary>
    public interface ICacheSendNotice
    {
        /// <summary>
        /// 发送缓存变更
        /// </summary>
        /// <param name="key">缓存Key</param>
        void SendClearCache(string key);

        /// <summary>
        /// 发送缓存多个变更
        /// </summary>
        /// <param name="key">缓存Key集合</param>
        void SendClearCaches(List<string> keys);
    }

    /// <summary>
    /// 本地缓存容器通知服务
    /// </summary>
    public class LocalCacheSendNotice : ICacheSendNotice
    {
        public void SendClearCache(string key)
        {
            ReceiveCacheNotice.ReceiveClearCache(key);
        }

        public void SendClearCaches(List<string> keys)
        {
            ReceiveCacheNotice.ReceiveClearCaches(keys);
        }
    }
/// <summary>
    /// Redis缓存容器通知服务
    /// </summary>
    public class RedisCacheSendNotice : ICacheSendNotice
    {
        private readonly SpriteConfig _callHttpConfig;
        private readonly IDistributedCache _distributedCache;
        private readonly ISubscriber _subscriber;

        public RedisCacheSendNotice(IDistributedCache distributedCache, IOptions<SpriteConfig> callHttpConfig)
        {
            _distributedCache = distributedCache;
            _callHttpConfig = callHttpConfig.Value;
            var spriteRedisCache = _distributedCache as SpriteRedisCache;
            spriteRedisCache.RedisDatabase.Multiplexer.ConnectionFailed += Multiplexer_ConnectionFailed;
            spriteRedisCache.RedisDatabase.Multiplexer.ConnectionRestored += Multiplexer_ConnectionRestored;
            _subscriber = spriteRedisCache.RedisDatabase.Multiplexer.GetSubscriber();

            if (_callHttpConfig.RemoteReceivePreKey != null)
            {
                foreach (var remoteReceivePreKey in _callHttpConfig.RemoteReceivePreKey)
                {
                    _subscriber.Subscribe(remoteReceivePreKey, (channel, message) =>
                    {
                        ReceiveCacheNotice.ReceiveClearCache(message);
                    });

                    _subscriber.Subscribe($"{remoteReceivePreKey}s", (channel, message) =>
                    {
                        List<string> keys = JsonConvert.DeserializeObject<List<string>>(message);
                        ReceiveCacheNotice.ReceiveClearCaches(keys);
                    });
                }
            }
        }

        private void Multiplexer_ConnectionRestored(object sender, StackExchange.Redis.ConnectionFailedEventArgs e)
        {
            ReceiveCacheNotice.SetLocalCacheIsEnabled(true);
        }

        private void Multiplexer_ConnectionFailed(object sender, StackExchange.Redis.ConnectionFailedEventArgs e)
        {
            ReceiveCacheNotice.SetLocalCacheIsEnabled(false);
        }

        public void SendClearCache(string key)
        {
            ReceiveCacheNotice.ReceiveClearCache(key);
            if (_callHttpConfig.RemoteNoticePreKey != null)
            {
                if (_callHttpConfig.RemoteNoticePreKey.Any(r => key.StartsWith($"{r}-")))
                {
                    _subscriber.Publish(key.Split('-')[0], key);
                }
            }
        }

        public void SendClearCaches(List<string> keys)
        {
            ReceiveCacheNotice.ReceiveClearCaches(keys);
            if (_callHttpConfig.RemoteNoticePreKey != null)
            {
                var groupKeyLists = keys.GroupBy(r => r.Split('-')[0]);
                foreach (var groupKeyList in groupKeyLists)
                {

                    if (_callHttpConfig.RemoteNoticePreKey.Any(r => groupKeyList.Key == r))
                    {
                        _subscriber.Publish($"{groupKeyList.Key}s", JsonConvert.SerializeObject(groupKeyList.ToList()));
                    }
                }
            }
        }
    }
public class SpriteFormLocalCache : LocalCache<SpriteFormVueDto>
    {
        public override string CacheKey => CommonConsts.SpriteFormCacheKey;

        public override Dictionary<Guid, SpriteFormVueDto> GetAllDict(string applicationCode)
        {
            if (!LocalCacheContainer.IsEnabledLocalCache) // 如果缓存通知服务不可以,直接读取数据库
            {
                return _serviceProvider.DoDapperService(DefaultDbConfig, (unitOfWork) =>
                {
                    return GetSpriteFormVueDtos(applicationCode, unitOfWork);
                });
            }
            else
            {
	// 读取本地缓存内容,如果本地缓存没有数据,读取数据库数据,并写入本地缓存容器
                return (Dictionary<Guid, SpriteFormVueDto>)LocalCacheContainer.Get($"{CommonConsts.SpriteFormCachePreKey}-{applicationCode}_{CacheKey}", key =>
                {
                    return _serviceProvider.DoDapperService(DefaultDbConfig, (unitOfWork) =>
                    {
                        return GetSpriteFormVueDtos(applicationCode, unitOfWork);
                    });
                });
            }
        }
......
}
import Dexie from 'dexie'
import { SpriteRumtimeApi } from '@/sprite/api/spriteform'

const db = new Dexie('formDb')
db.version(1).stores({
    form: `id`
})

db.version(1).stores({
    view: `id`
})

db.version(1).stores({
    frameworkCache: `id`
})

db.version(1).stores({
    dict: `id`
})

window.spriteDb = db

db.menuFormRelationInfo = {}
const createMenuFormRelations = function (routeName, applicationCode, relationInfos) {
    if (!db.menuFormRelationInfo.hasOwnProperty(routeName)) {
        db.menuFormRelationInfo[routeName] = {}
        db.menuFormRelationInfo[routeName].applicationCode = applicationCode
        db.menuFormRelationInfo[routeName].relationInfos = relationInfos
    } else {
        relationInfos.forEach(relationInfo => {
            if (!db.menuFormRelationInfo[routeName].relationInfos.find(r => r.relationType === relationInfo.relationType && r.id === relationInfo.id && r.version === relationInfo.version)) {
                db.menuFormRelationInfo[routeName].relationInfos.push(relationInfo)
            } 
        });
    }
}

/**
 * 递归获取表单或视图关联表单视图版本信息
 * @param {guid} objId 表单或视图Id
 * @param {int} relationType 1=表单,2=视图
 * @param {obj} relationInfos 表单和视图版本信息
 */
const findRelationConfigs = async function (objId, relationType, relationInfos) {
    if (!relationInfos) {
        relationInfos = []
    }
    console.log(relationType)
    var findData = relationType === 1 ? await db.form.get(objId) : await db.view.get(objId)
    if (findData && relationInfos.findIndex(r => r.id === findData.id) < 0) {
        relationInfos.push({ relationType: relationType, id: findData.id, version: findData.version })
    }
    if (findData && findData.relationInfos && findData.relationInfos.length > 0) {
        for (var i = 0; i < findData.relationInfos.length; i++) {
            await findRelationConfigs(findData.relationInfos[i].id, findData.relationInfos[i].relationType, relationInfos)
        }
    }
    console.log('relationInfos')
    console.log(relationInfos)
    return relationInfos
}

db.getFormData = async function (routeName, formId, fromMenu, applicationCode) {
    var formData = await db.form.get(formId)
    var dictFrameworkCache = await db.frameworkCache.get('dict')
    console.log("getFormData")
    if (!formData) {
        var resultData = await SpriteRumtimeApi.simpleform({ id: formId, applicationCode: applicationCode })
        var menuFormrelationInfos = []
        if (resultData && resultData) {
            for (var i = 0; i < resultData.formDatas.length; i++) {
                await db.form.put(resultData.formDatas[i])
                menuFormrelationInfos.push({relationType: 1, id: resultData.formDatas[i].id, version: resultData.formDatas[i].version})
            }
            for (var j = 0; j < resultData.viewDatas.length; j++) {
                await db.view.put(resultData.viewDatas[j])
                menuFormrelationInfos.push({relationType: 2, id: resultData.viewDatas[j].id, version: resultData.viewDatas[j].version})
            }
        }
        if (resultData && resultData.dictVersion && resultData.dicts) {
            await db.frameworkCache.put({ id: 'dict', version: resultData.dictVersion })
            await db.dict.clear()
            await db.dict.bulkAdd(resultData.dicts)
        }
        createMenuFormRelations(routeName, applicationCode, menuFormrelationInfos)
        formData = await db.form.get(formId)
    } else { // 从indexdb找到数据,如果从菜单进入,需要调用接口,判断版本号信息
        if (fromMenu) {
            delete db.menuFormRelationInfo[routeName]
            var relationInfos = await findRelationConfigs(formId, 1, [])
            var relationParams = { applicationCode: applicationCode, formId: formId, relationInfos: relationInfos, dictVersion: dictFrameworkCache?.version }
            var checkResult = await SpriteRumtimeApi.checkversions(relationParams)
            if ((checkResult && checkResult.formDatas && checkResult.formDatas.length > 0) || (checkResult && checkResult.viewDatas && checkResult.viewDatas.length > 0)) {
                relationInfos = []
            }
            if (checkResult && checkResult.formDatas && checkResult.formDatas.length > 0) {
                for (var i2 = 0; i2 < checkResult.formDatas.length; i2++) {
                    await db.form.put(checkResult.formDatas[i2])
                    relationInfos.push({relationType: 1, id: checkResult.formDatas[i2].id, version: checkResult.formDatas[i2].version})
                }
            }
            if (checkResult && checkResult.viewDatas && checkResult.viewDatas.length > 0) {
                for (var j2 = 0; j2 < checkResult.viewDatas.length; j2++) {
                    await db.view.put(checkResult.viewDatas[j2])
                    relationInfos.push({relationType: 2, id: checkResult.viewDatas[j2].id, version: checkResult.viewDatas[j2].version})
                }
            }
            if (checkResult && checkResult.dictVersion && checkResult.dicts) {
                await db.frameworkCache.put({ id: 'dict', version: checkResult.dictVersion })
                await db.dict.clear()
                await db.dict.bulkAdd(checkResult.dicts)
            }
            createMenuFormRelations(routeName, applicationCode, relationInfos)
            formData = await db.form.get(formId)
        }
    }
    return formData
}

 

开源地址:https://gitee.com/kuangqifu/sprite

体验地址:http://47.108.141.193:8031(首次加载可能有点慢,用的阿里云最差的服务器)

自定义表单文章地址:https://www.cnblogs.com/spritekuang/

流程引擎文章地址:https://www.cnblogs.com/spritekuang/category/834975.html(采用WWF开发,已过时,已改用Elsa实现,https://www.cnblogs.com/spritekuang/p/14970992.html )

Github地址:https://github.com/kuangqifu/CK.Sprite.Job

 

标签:缓存,自定义,relationInfos,--,db,企业级,checkResult,key,id
来源: https://www.cnblogs.com/spritekuang/p/15876299.html