4.2 多级可换源的配置（下）

前面已经实现了Json配置源的方式，以及在Startup中注册使用我们的配置源。下面我们进入重点，就是如何实现数据库方式的配置。数据表对应的实体类和DbContext代码如下，就不写数据表的结构了:)

    public class ConfigurationSectionInfo
    {
        public string AppCode { get; set; }
        public string SectionCode { get; set; }
        public string SectionName { get; set; }
        public string SectionString { get; set; }
    }

    public class ConfigurationContext : DbContext
    {
        public ConfigurationContext(DbContextOptions options) : base(options)
        {
        }

        public DbSet<ConfigurationSectionInfo> ConfigurationSections { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            EntityTypeBuilder<ConfigurationSectionInfo> builder = modelBuilder.Entity<ConfigurationSectionInfo>();

            builder.ToTable("CONFIGURATION_SECTION_INFO");
            builder.Property(c => c.AppCode).HasColumnName("APP_CODE").IsRequired();
            builder.Property(c => c.SectionCode).HasColumnName("SECTION_CODE").IsRequired();
            builder.Property(c => c.SectionName).HasColumnName("SECTION_NAME").IsRequired();
            builder.Property(c => c.SectionString).HasColumnName("SECTION_STRING").IsRequired();

            builder.HasKey(c => new { c.AppCode, c.SectionCode });
        }
    }

在.net core的文档中，也写了一个数据库方式。但是该方式，是每一个键值对都存放到数据库中，例如一个缓存配置就包含MicroStrutLibrary:Caching:DefaultSlidingTime、MicroStrutLibrary:Caching:Type等多条记录，配置分散不说，写起来非常麻烦，也不如像上图中看起来那么有条理。

 

接下来就是数据库的配置源类DatabaseConfigSource，继承我们自己的基类ConfigSource，并实现GetConfigurationRoot方法。

    [TypeName("Database", "数据库配置")]
    public class DatabaseConfigSource : ConfigSource
    {
        public DatabaseConfigSource(string parameter) : base(parameter)
        {
        }

        public override IConfigurationRoot GetConfigurationRoot()
        {
            AppConfigInfo config = AppConfigInfo.GetConfig();

            ConfigurationBuilder builder = new ConfigurationBuilder();
            builder.Add(new DbConfigurationSource(options => options.UseSqlServer(_Parameter), config.AppCode));

            return builder.Build();
        }
    }

需要注意的是AppConfigInfo类，这个类我们用到的是AppCode属性，AppCode是指应用程序代码。因为我们的公共配置可以给多个应用使用，因此数据库方式获取配置时必须传入AppCode。在这里的意思是获取与应用程序（AppCode）相关的配置项。因为配置数据表中可能存在许多个应用的配置信息，我们这里只获取当前应用的配置信息。Parameter参数就是数据库链接串，可以在前面一节ConfigSource类的介绍中明显的看到。

创建ConfigurationBuilder，添加IConfigurationSource的数据库实现--DbConfigurationSource，其核心是DbConfigurationProvider。DbConfigurationSource和DbConfigurationProvider的实现如下：

    public class DbConfigurationSource : IConfigurationSource
    {
        private readonly Action<DbContextOptionsBuilder> _optionsAction;
        private readonly string appCode;

        public DbConfigurationSource(Action<DbContextOptionsBuilder> optionsAction, string appCode)
        {
            _optionsAction = optionsAction;
            this.appCode = appCode;
        }

        public IConfigurationProvider Build(IConfigurationBuilder builder)
        {
            return new DbConfigurationProvider(_optionsAction, appCode);
        }
    }

    public class DbConfigurationProvider : ConfigurationProvider
    {
        private Action<DbContextOptionsBuilder> optionsAction;
        private string appCode;

        public DbConfigurationProvider(Action<DbContextOptionsBuilder> optionsAction, string appCode)
        {
            this.optionsAction = optionsAction;
            this.appCode = appCode;
        }

        public override void Load()
        {
            var builder = new DbContextOptionsBuilder<ConfigurationContext>();
            optionsAction(builder);

            using (var dbContext = new ConfigurationContext(builder.Options))
            {
                dbContext.Database.EnsureCreated();
                Data = GetConfigData(dbContext);
            }
        }

        private IDictionary<string, string> GetConfigData(ConfigurationContext dbContext)
        {
            List<string> configSections = new List<string>();

            var appConfigs = dbContext.ConfigurationSections.Where(a => a.AppCode == this.appCode);
            foreach (ConfigurationSectionInfo info in appConfigs)
            {
                configSections.Add(""" + info.SectionCode + "":{" + info.SectionString + "}");
            }

            var defConfigs = dbContext.ConfigurationSections.Where(d => string.IsNullOrEmpty(d.AppCode) && appConfigs.Any(a => a.SectionCode == d.SectionCode));
            foreach (ConfigurationSectionInfo info in defConfigs)
            {
                configSections.Add(""" + info.SectionCode + "":{" + info.SectionString + "}");
            }

            string configs = "{"MicroStrutLibrary":{" + string.Join(",", configSections) + "}}";

            return JsonConfigurationParser.Parse(configs);
        }
    }

DbConfigurationProvider程序的大体流程是：从数据库中读取与本应用（AppCode）相关的配置节，再读取所有应用为空的配置节（缺省配置节），然后所有配置节合并成为一个总的配置字符串，最后调用解析方法生成配置的Key/Value。解析的代码：

    public static class JsonConfigurationParser
    {
        private static IDictionary<string, string> _data;
        private static Stack<string> _context;
        private static string _currentPath;

        static JsonConfigurationParser()
        {
            _data = new SortedDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            _context = new Stack<string>();
        }

        public static IDictionary<string, string> Parse(string configs)
        {
            _data.Clear();

            var jsonConfig = JObject.Parse(configs);

            VisitJObject(jsonConfig);

            return _data;
        }

        private static void VisitJObject(JObject jObject)
        {
            foreach (var property in jObject.Properties())
            {
                EnterContext(property.Name);
                VisitProperty(property);
                ExitContext();
            }
        }

        private static void VisitProperty(JProperty property)
        {
            VisitToken(property.Value);
        }

        private static void VisitToken(JToken token)
        {
            switch (token.Type)
            {
                case JTokenType.Object:
                    VisitJObject(token.Value<JObject>());
                    break;

                case JTokenType.Array:
                    VisitArray(token.Value<JArray>());
                    break;

                case JTokenType.Integer:
                case JTokenType.Float:
                case JTokenType.String:
                case JTokenType.Boolean:
                case JTokenType.Bytes:
                case JTokenType.Raw:
                case JTokenType.Null:
                    VisitPrimitive(token);
                    break;
                default:
                    MicroStrutLibraryExceptionHelper.Throw(typeof(JsonConfigurationParser).FullName, LogLevel.Error, "类型不正确！");
                    break;
            }
        }

        private static void VisitArray(JArray array)
        {
            for (int index = 0; index < array.Count; index++)
            {
                EnterContext(index.ToString());
                VisitToken(array[index]);
                ExitContext();
            }
        }

        private static void VisitPrimitive(JToken data)
        {
            var key = _currentPath;

            MicroStrutLibraryExceptionHelper.TrueThrow(_data.ContainsKey(key), typeof(JsonConfigurationParser).FullName, LogLevel.Error, $"键值{key}重复");

            _data[key] = data.ToString();
        }

        private static void EnterContext(string context)
        {
            _context.Push(context);
            _currentPath = ConfigurationPath.Combine(_context.Reverse());
        }

        private static void ExitContext()
        {
            _context.Pop();
            _currentPath = ConfigurationPath.Combine(_context.Reverse());
        }
    }

这个解析类的代码基本照.net core的源代码复制而来。

面向云的.net core开发框架目录