CYQ.Data V5 分布式自动化缓存设计介绍（二）

前言：

最近一段时间，开始了《IT连》创业，所以精力和写的文章多数是在分享创业的过程。

而关于本人三大框架CYQ.Data、Aries、Taurus.MVC的相关文章，基本都很少写了。

但框架的维护升级，还是时不时的在进行中的，这点从开源的Github上的代码提交时间上就可以看出来了。

毕竟《IT连》的后台WebAPI，用的是Taurus.MVC，后台系统管理用的是Aries。

不过今天，就不写创业相关的文章了，先分享篇技术类的文章。

CYQ.Data 分布式自动缓存

之前写过一篇：CYQ.Data V5 分布式自动化缓存设计介绍。

在上一篇里，基本情况和思路，已经介绍的很清楚，这里就简单补充2点：

1：自动缓存默认是开启状态的，相关控制和配置如下：

需要全局关闭时：

可以在应用程序启动时的入口用代码：

AppConfig.Cache.IsAutoCache=false;

或者app.config、web.config配置：

<appSettings>
    <add key="IsAutoCache" value="false"/>
</appSettings>

需要代码局部关闭时：

using (MAction action = new MAction("表名"))
{
     action.SetAopState(CYQ.Data.Aop.AopOp.OnlyOuter);//关闭自动缓存并保留Aop
}

用代码控制清除表缓存时：

string key= CacheManage.GetKey(CacheKeyType.AutoCache, "表名");
CacheManage.Instance.Remove(key);

其它控制的配置项：

            /// <summary>
            /// AutoCache开启时，可以设置不缓存的Table，多个用逗号分隔
            /// </summary>
            public static string NoCacheTables
            {
                get
                {
                    return GetApp("NoCacheTables", "");
                }
                set
                {
                    SetApp("NoCacheTables", value);
                    CYQ.Data.Cache.AutoCache.NoCacheTables = null;
                }
            }

            /// <summary>
            /// AutoCache开启时，可以设置不受更新影响的列名，用Json格式。
            /// {talbeName1:'column1,column2',talbeName2:'column1,column2'}
            /// </summary>
            public static string IngoreCacheColumns
            {
                get
                {
                    return GetApp("IngoreCacheColumns", "");
                }
                set
                {
                    SetApp("IngoreCacheColumns", value);
                    CYQ.Data.Cache.AutoCache.IngoreCacheColumns = null;
                }
            }

2：分布式应用时的缓存控制

对于单一应用程序，框架已经处理的很好。

而对于多个应用程序，框架提供的方案是通过配置启用分布式缓存MemCache或Redis。

相关的配置如下（AppConfig下的都可以对应web.config下的AppSettings项）：

            /// <summary>
            /// MemCache分布式缓存的服务器配置，多个用逗号（,）分隔
            /// </summary>
            public static string MemCacheServers
            {
                get
                {
                    return GetApp("MemCacheServers", string.Empty);
                }
                set
                {
                    SetApp("MemCacheServers", value);
                }
            }

            /// <summary>
            /// MemCache 备份服务器（当主服务器挂了后，请求会转向备用机）
            /// </summary>
            public static string MemCacheServersBak
            {
                get
                {
                    return GetApp("MemCacheServersBak", string.Empty);
                }
                set
                {
                    SetApp("MemCacheServersBak", value);
                }
            }

            /// <summary>
            /// Redis分布式缓存的服务器配置，多个用逗号（,）分隔
            /// </summary>
            public static string RedisServers
            {
                get
                {
                    return GetApp("RedisServers", string.Empty);
                }
                set
                {
                    SetApp("RedisServers", value);
                }
            }
            /// <summary>
            /// Redis 使用的DB数（默认1，使用db0）
            /// </summary>
            public static int RedisUseDBCount
            {
                get
                {
                    return GetAppInt("RedisUseDBCount", 1);
                }
                set
                {
                    SetApp("RedisUseDBCount", value.ToString());
                }
            }
            /// <summary>
            /// Redis 使用的DB 索引（默认0，若配置，则会忽略RedisUseDBCount）
            /// </summary>
            public static int RedisUseDBIndex
            {
                get
                {
                    return GetAppInt("RedisUseDBIndex", 0);
                }
                set
                {
                    SetApp("RedisUseDBIndex", value.ToString());
                }
            }
            /// <summary>
            /// Redis  备份服务器（当主服务器挂了后，请求会转向备用机）
            /// </summary>
            public static string RedisServersBak
            {
                get
                {
                    return GetApp("RedisServersBak", string.Empty);
                }
                set
                {
                    SetApp("RedisServersBak", value);
                }
            }

分布式下缓存的失效策略升级

在多个应用程序时，分布式缓存可以集中控制，固然是一种方案。

但对于单一的服务器来说，开始思考有没有更简单的方案，可以不装MemCache或Redis。

比如《IT连》创业项目的webapi和aries后台是两套程序，同一个服务器下共同操作一个数据库，各自有自动缓存的情况下。

经过思考，最后选择了通过定时扫描表来处理。

方案原理：

每个应用程序，只要配置好数据库链接（配置的数据库可以是任意的）：

            /// <summary>
            /// CYQ.Data.Cache 自动缓存 - 数据库链接配置
            /// 在多个不同的应用项目里操作同一个数据库时（又不想使用分布式缓存MemCache或Redis），可以开启此项，达到缓存智能清除的效果。
            /// </summary>
            public static string AutoCacheConn
            {
                get
                {
                    if (_AutoCacheConn == null)
                    {
                        _AutoCacheConn = AppConfig.GetConn("AutoCacheConn");
                    }
                    return _AutoCacheConn;
                }
                set
                {
                    _AutoCacheConn = value;
                }
            }        

接着框架会自动创建一个SysAutoCache表，包含CacheKey和CacheTime两列：

接着框架会有定时扫描，来处理：

 public static void AutoCacheKeyTask(object threadID)
        {
           
            while (true)//定时扫描数据库
            {
                int time = AppConfig.Cache.AutoCacheTaskTime;
                if (time <= 0)
                {
                    time = 1000;
                }
                Thread.Sleep(time);
                if (removeListForKeyTask.Count > 0)
                {
                    string baseKey = removeListForKeyTask.Dequeue();
                    if (!string.IsNullOrEmpty(baseKey))
                    {
                        KeyTable.SetKey(baseKey);
                    }
                }
                if (KeyTable.HasAutoCacheTable) //读取看有没有需要移除的键。
                {
                    KeyTable.ReadAndRemoveKey();
                }
            }
        }

默认是1秒扫一次，你也可以自己配置扫描的间隔时间：

            /// <summary>
            /// 当AutoCacheConn开启后，定时扫描数据库的任务时间（毫秒）,默认1000
            /// </summary>
            public static int AutoCacheTaskTime
            {
                get
                {
                    return GetAppInt("AutoCacheTaskTime", 1000);
                }
                set
                {
                    SetApp("AutoCacheTaskTime", value.ToString());
                }

            }

总结：

对于本次升级来了两个好处：

1：多应用下更简单了，多了一种可选方案。

2：对于喜欢手动修改数据库数据的，或对于框架无法监控的存储过程代码，也可以手工或存储过程中更新SysAutoCache表的时间，以便于通知框架更新缓存。

整体而言：

1：自动缓存能将你的应用程序提升一个质量的飞跃。

2：自动在一些大型的项目里，应该用的更精致一些，配置好哪些表不需要缓存，哪些列的更新不影响缓存。

3：请保存系统有足够的缓存。