发现ABP——使用Redis

　　Redis是项目中普遍使用到的缓存组件，在Abp中如何使用呢！

　　首先先大概的看下abp源码结构：

　　

从结构就能看出abp使用了StackExchange.Redis，展开包可看出其实它是引用的Microsoft.Extensions.Caching.StackExchangeRedis

还发现这里面还有UnitOfWork，还有待研究~~

系统中如何使用呢？

1、添加abp的包引用

可以通过cli命令添加：abp add-package Volo.Abp.Caching.StackExchangeRedis（注意要在使用缓存的项目中执行命令，在此为Application层，可自动向Module类添加DependsOn引用），

也可手动通过nuget包添加引用（添加引用后要在对应的Module类中手动添加DependsOn引用），效果如下：

namespace abcFlow.WorkFlowEngine
{
    [DependsOn(
        typeof(WorkFlowEngineDomainModule),
        typeof(WorkFlowEngineApplicationContractsModule),
        typeof(AbpDddApplicationModule),
        typeof(AbpAutoMapperModule)
        )]
    [DependsOn(typeof(AbpCachingStackExchangeRedisModule))]
    public class WorkFlowEngineApplicationModule : AbpModule
    {
        public override void ConfigureServices(ServiceConfigurationContext context)
        {
            context.Services.AddAutoMapperObjectMapper<WorkFlowEngineApplicationModule>();
            Configure<AbpAutoMapperOptions>(options =>
            {
                options.AddMaps<WorkFlowEngineApplicationModule>(validate: true);
            });


            Configure<AbpDistributedCacheOptions>(options =>
            {
                options.KeyPrefix = "demo";
                options.HideErrors = false;
            });
        }
    }
}

代码中也添加了对AbpDistributedCacheOptions的配置，分别对应缓存前缀以及是否要隐藏错误（默认为true，在此为实验目的设为false）；

2、设置redis连接属性

abp同样提供了appsettings.json文件配置以及在Module中通过ConfigureServices方法中配置，在此以appsettings.json为例：

  "Redis": {
    "IsEnabled": "true",
    "Configuration": "127.0.0.1"
  }

配置显示声明启用Redis并设置IP地址，本机端口号默认、无密码，该配置与StackExchangeRedis是一致的，可以进行验证下，包含集群模式也可以进行验证，问题不大。

以上就将Redis的配置设置好了，下面看下如何进行数据的读写：

3、Redis的数据读写

数据的读写放在Application层，调用方式如下：

using JetBrains.Annotations;
using System;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Caching;

namespace abcFlow.WorkFlowEngine.FlowDesign
{
    public class WfSchemeAppService : WorkFlowEngineAppService, IWfSchemeAppService
    {
        private readonly IWfSchemeRepository _wfSchemeRepository;
        private readonly IDistributedCache<WfSchemeDto> _distributedCache;

        public WfSchemeAppService(
            IWfSchemeRepository wfSchemeRepository,
            IDistributedCache<WfSchemeDto> distributedCache)
        {
            this._wfSchemeRepository = wfSchemeRepository;
            this._distributedCache = distributedCache;
        }

        public async Task<WfSchemeDto> FindAsync([NotNull] Guid id)
        {
            Check.NotNull(id, nameof(id));
            return await _distributedCache.GetOrAddAsync(
                id.ToString(),
                async () => await GetWfSchemeById(id),
                () => new Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions
                {
                    AbsoluteExpiration = DateTimeOffset.Now.AddHours(2)
                });
        }

        private async Task<WfSchemeDto> GetWfSchemeById(Guid id)
        {
            var obj = await _wfSchemeRepository.FindAsync(id);
            return ObjectMapper.Map<WfScheme, WfSchemeDto>(obj);
        }
    }
}

• 首先进行注入IDistributedCache，在此指定了缓存的数据类型
• 通过方法_distributedCache.GetOrAddAsync来实现缓存数据的读写（无数据时先加载数据再插入缓存），还可进行过期时间设置（在此可将时间提出出来作为常量）

看下Redis中存储的对象：

最后看下GetOrAddAsync的代码：

        /// <summary>
        /// Gets or Adds a cache item with the given key. If no cache item is found for the given key then adds a cache item
        /// provided by <paramref name="factory" /> delegate and returns the provided cache item.
        /// </summary>
        /// <param name="key">The key of cached item to be retrieved from the cache.</param>
        /// <param name="factory">The factory delegate is used to provide the cache item when no cache item is found for the given <paramref name="key" />.</param>
        /// <param name="optionsFactory">The cache options for the factory delegate.</param>
        /// <param name="hideErrors">Indicates to throw or hide the exceptions for the distributed cache.</param>
        /// <param name="considerUow">This will store the cache in the current unit of work until the end of the current unit of work does not really affect the cache.</param>
        /// <param name="token">The <see cref="T:System.Threading.CancellationToken" /> for the task.</param>
        /// <returns>The cache item.</returns>
        public virtual async Task<TCacheItem> GetOrAddAsync(
            TCacheKey key,
            Func<Task<TCacheItem>> factory,
            Func<DistributedCacheEntryOptions> optionsFactory = null,
            bool? hideErrors = null,
            bool considerUow = false,
            CancellationToken token = default)
        {
            token = CancellationTokenProvider.FallbackToProvider(token);
            var value = await GetAsync(key, hideErrors, considerUow, token);
            if (value != null)
            {
                return value;
            }

            using (await SyncSemaphore.LockAsync(token))
            {
                value = await GetAsync(key, hideErrors, considerUow, token);
                if (value != null)
                {
                    return value;
                }

                value = await factory();

                if (ShouldConsiderUow(considerUow))
                {
                    var uowCache = GetUnitOfWorkCache();
                    if (uowCache.TryGetValue(key, out var item))
                    {
                        item.SetValue(value);
                    }
                    else
                    {
                        uowCache.Add(key, new UnitOfWorkCacheItem<TCacheItem>(value));
                    }
                }

                await SetAsync(key, value, optionsFactory?.Invoke(), hideErrors, considerUow, token);
            }

            return value;
        }

From：发现ABP——使用Redis - 屈鲁奇 - 博客园 (cnblogs.com)