如何优雅的使用AbpSettings

在Abp中配置虽然使用方便，但是每个配置要先定义key，要去provider中定义，再最后使用key从ISetting中获取还是挺麻烦的一件事，

最主要是获取修改的时候，比如，修改用户配置，是从获取一批key/value来返回前端，并从前端提交修改保存就比较麻烦了。

很早之前做过一些尝试，如下：

https://www.cnblogs.com/crazyboy/p/8064387.html

但是那个时候比较菜也没怎么搞太清楚所以感觉也不太好用。

之前也想过使用定义配置类使用基类中注入的ISettingManager的方式来处理，如下

        public string Item
        {
            get { return this.SettingManager.GetSettingValue(nameof(Item)); }
            set { this.SettingManager.ChangeSettingForApplication(nameof(Item), value); }
        }

但是这样对配置类污染比较大，也就放弃了，前段时间在看Abp源代码的时候，突然想到，是否可以通过拦截器来代理配置类的get ,set方法来达到获取和修改配置的目的呢

于是便开始了配置的改造工作，首先，定义一个配置的接口来注册拦截器：

 using Abp.Dependency;

 namespace SKYS.Charger.Configuration
 {
     /// <summary>
     /// 配置类接口，要实现从SettingManager更新/获取数据，请所有属性用virtual标识
     /// </summary>
     public interface ISettings : ISingletonDependency
     {

     }
 }

为了定义设置的一些配置，我们还需要定义一个特性用于设置的默认值/范围等：

using Abp.Configuration;
using System;

namespace SKYS.Charger.Configuration
{
    [AttributeUsage(AttributeTargets.Property)]
    public class AutoSettingDefinitionAttribute : Attribute
    {
        public object DefaultValue { get; private set; }

        public bool IsVisibleToClients { get; private set; }

        public SettingScopes Scopes { get; private set; }

        public AutoSettingDefinitionAttribute(object defaultValue, bool isVisibleToClients = true, SettingScopes scopes = SettingScopes.Application)
        {
            this.DefaultValue = defaultValue;
            this.IsVisibleToClients = isVisibleToClients;
            this.Scopes = scopes;
        }
    }
}

接下来，我们需要把所有继承至ISettings的设置类都注册到SettingProvider中，这里我直接使用的反射，从属性特性上读取设置的配置：

 using Abp.Configuration;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;

 namespace SKYS.Charger.Configuration
 {
     /// <summary>
     ///
     /// </summary>
     public class AutoSettingsProvider : SettingProvider
     {
         public override IEnumerable<SettingDefinition> GetSettingDefinitions(SettingDefinitionProviderContext context)
         {
             var settings = new List<SettingDefinition>();

             var types = this.GetType().Assembly
                                       .GetTypes()
                                       .Where(t => t.IsClass && typeof(ISettings).IsAssignableFrom(t));

             foreach (var type in types)
             {
                 var scopes = SettingScopes.All;
                 foreach (var p in type.GetProperties())
                 {
                     var key = AutoSettingsUtils.CreateSettingName(type, p.Name);
                     var isVisibleToClients = false;
                     var defaultValue = AutoSettingsUtils.GetDefaultValue(p.PropertyType);
                     var attr = p.GetCustomAttribute<AutoSettingDefinitionAttribute>();
                     if (attr != null)
                     {
                         scopes = attr.Scopes;
                         defaultValue = attr.DefaultValue;
                         isVisibleToClients = attr.IsVisibleToClients;
                     }
                     settings.Add(new SettingDefinition(
                            name: key,
                            defaultValue: defaultValue?.ToString(),
                            scopes: scopes,
                            isVisibleToClients: isVisibleToClients
                             ));
                 }
             }

             return settings;
         }
     }
 }

接下来定义一个Interceptor用于拦截设置类中属性的get/set方法，在拦截器中注入了ISettingManager及AbpSession用于获取和修改设置，在修改的时候如果scope支持User优先修改用户设置，然后是租户设置，最后是应用设置

 using Abp.Configuration;
 using Abp.Runtime.Session;
 using Castle.DynamicProxy;
 using SKYS.Charger.Utilities;

 namespace SKYS.Charger.Configuration
 {
     /// <summary>
     /// 自动配置拦截器，用于获取/修改配置值
     /// </summary>
     public class AutoSettingsInterceptor : IInterceptor
     {
         private readonly ISettingManager _settingManager;
         private readonly ISettingDefinitionManager _settingDefinitionManager;
         public IAbpSession AbpSession { get; set; }
         public AutoSettingsInterceptor(ISettingManager settingManager, ISettingDefinitionManager settingDefinitionManager)
         {
             this._settingManager = settingManager;
             this._settingDefinitionManager = settingDefinitionManager;
             this.AbpSession = NullAbpSession.Instance;
         }

         protected void PostProceed(IInvocation invocation)
         {
             var setFlag = "set_";
             var getFlag = "get_";

             var isSet = invocation.Method.Name.StartsWith(setFlag);
             var isGet = invocation.Method.Name.StartsWith(getFlag);
             //非属性方法不处理
             if (!isSet && !isGet)
                 return;

             var pname = invocation.Method.Name.Replace(setFlag, "")
                                               .Replace(getFlag, "");
             var settingName = AutoSettingsUtils.CreateSettingName(invocation.TargetType, pname);
             //配置 设置
             if (isSet)
             {
                 var setting = this._settingDefinitionManager.GetSettingDefinition(settingName);
                 this.ChangeSettingValue(setting, invocation.Arguments[]?.ToString());
             }
             //配置 获取
             else
             {
                 var val = this._settingManager.GetSettingValue(settingName);
                 invocation.ReturnValue = ConvertHelper.ChangeType(val, invocation.Method.ReturnType);
             }
         }
         protected void ChangeSettingValue(SettingDefinition settings, object value)
         {
             var val = value?.ToString();
             if (settings.Scopes.HasFlag(SettingScopes.User) && this.AbpSession.UserId.HasValue)
                 this._settingManager.ChangeSettingForUser(this.AbpSession.ToUserIdentifier(), settings.Name, val);
             else if (settings.Scopes.HasFlag(SettingScopes.Tenant) && this.AbpSession.TenantId.HasValue)
                 this._settingManager.ChangeSettingForTenant(this.AbpSession.TenantId.Value, settings.Name, val);
             else if (settings.Scopes.HasFlag(SettingScopes.Application))
                 this._settingManager.ChangeSettingForApplication(settings.Name, val);
         }

         public void Intercept(IInvocation invocation)
         {
             invocation.Proceed();
             this.PostProceed(invocation);
         }
     }
 }

定义完以后，我们还需要注册我们的拦截器，这里我使用了一个Manager来注册，通过传入AbpModule中的Configuration来完成注册

 using Abp.Configuration.Startup;
 using Castle.Core;

 namespace SKYS.Charger.Configuration
 {
     public class AutoSettingsManager
     {
         public static void Initialize(IAbpStartupConfiguration configuration)
         {
             configuration.IocManager.IocContainer.Kernel.ComponentRegistered += (key, handler) =>
             {
                 if (typeof(ISettings).IsAssignableFrom(handler.ComponentModel.Implementation))
                 {
                     handler.ComponentModel.Interceptors.Add(new InterceptorReference(typeof(AutoSettingsInterceptor)));
                 }
             };

 　　　　　　　//把自动属性的Provider注册
             configuration.Settings.Providers.Add<AutoSettingsProvider>();
         }
     }
 }

然后在你定义配置类型的Module的PreInitialize()中完成注册：

//自动配置初始化
            AutoSettingsManager.Initialize(Configuration);

到这里我们的工作基本上也就完成了，接下来我们就可以定义我们自己的设置类了，因为我们注入使用是类，所以定义的属性都需要加上virtual以便拦截器能正常工具

 using Abp.AutoMapper;
 using Abp.Configuration;

 namespace SKYS.Charger.Configuration.Settings
 {
     [AutoMap(typeof(AppSettings))]
     public class AppSettings : ISettings
     {
         [AutoSettingDefinition("SKYS.Charger")]
         public virtual string SystemName { get; set; }

         [AutoSettingDefinition()]
         public virtual int PageSize { get; set; }

         /// <summary>
         /// 得现手续费
         /// </summary>
         [AutoSettingDefinition(0.02)]
         public virtual decimal TakeServiceFeeRate { get; set; }
     }
 }

在任意使用的地方，直接注入即可使用，并且只要是注入的配置类型，设置它的属性即可完成修改并保存到数据库，获取也是直接从ISettingManager中获取值，再配合前端修改的时候就方便多了

 namespace SKYS.Charger.Configuration
 {
     public class ConfigurationAppService : ApplicationService
     {
         private readonly AppSettings _appSettings;
         public ConfigurationAppService(AppSettings appSettings)
         {
             this._appSettings = appSettings;
         }

         /// <summary>
         /// 获取系统配置
         /// </summary>
         public async Task<AppSettings> GetSystemSettings()
         {
             return await Task.FromResult(_appSettings);
         }
         /// <summary>
         /// 修改系统配置
         /// </summary>
         [ManagerAuthorize]
         public async Task ChangeSystemSettings(AppSettings appSettings)
         {
             this.ObjectMapper.Map(appSettings, _appSettings);

             await Task.CompletedTask;
         }
     }
 }

是不是比原来的使用方式简单了很多呢，因为是所有配置类型都是ISingletonDependency在不方便的地方还可以直接使用IocManager.Instance.Resolve<AppSettings>()直接获取：

     public class PagedRequestFilter : IShouldNormalize
     {
         //public ISettingManager SettingManager { get; set; }

         public const int DefaultSize = ;

         //[Range(1, 10000)]
         public int Page { get; set; }

         //[Range(1,100)]
         public int Size { get; set; }

         public void Normalize()
         {
             if (this.Page <= )
                 this.Page = ;
             if (this.Size <= )
             {
                 var appSettings = IocManager.Instance.Resolve<AppSettings>();
                 this.Size = appSettings.PageSize;
             }
         }
     }

最后附上中间使用过的两个工具类AutoSettingsUtils和ConvertHelper

    public static class AutoSettingsUtils
    {
        public static string CreateSettingName(Type type, string propertyName)
        {
            return $"{type.Name}.{propertyName}";
        }

        public static object GetDefaultValue(Type targetType)
        {
            return targetType.IsValueType ? Activator.CreateInstance(targetType) : null;
        }
    }

     /// <summary>
     /// 数据转换帮助类
     /// </summary>
     public static class ConvertHelper
     {
         #region = ChangeType =
         public static object ChangeType(object obj, Type conversionType)
         {
             return ChangeType(obj, conversionType, Thread.CurrentThread.CurrentCulture);
         }
         public static object ChangeType(object obj, Type conversionType, IFormatProvider provider)
         {
             #region Nullable
             Type nullableType = Nullable.GetUnderlyingType(conversionType);
             if (nullableType != null)
             {
                 if (obj == null)
                 {
                     return null;
                 }
                 return Convert.ChangeType(obj, nullableType, provider);
             }
             #endregion
             if (typeof(System.Enum).IsAssignableFrom(conversionType))
             {
                 return Enum.Parse(conversionType, obj.ToString());
             }
             return Convert.ChangeType(obj, conversionType, provider);
         }
         #endregion
     }