發現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)