浅析 .Net Core中Json配置的自动更新

时间 2019-11-12

原文原文链接

Pre

很早在看 Jesse 的Asp.net Core快速入门的课程的时候就了解到了在Asp .net core中,若是添加的Json配置被更改了,是支持自动重载配置的,做为一名有着严重"造轮子"情节的程序员,最近在折腾一个博客系统,也想造出一个这样能自动更新以Mysql为数据源的ConfigureSource,因而点开了AddJsonFile这个拓展函数的源码,发现别有洞天,蛮有意思,本篇文章就简单地聊一聊Json config的ReloadOnChange是如何实现的,在学习ReloadOnChange的过程当中,咱们会把Configuration也顺带撩一把😁,但愿对小伙伴们有所帮助.html

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .ConfigureAppConfiguration(option =>
                    {
                        option.AddJsonFile("appsettings.json",optional:true,reloadOnChange:true);
                    })
                .UseStartup<Startup>();

在Asp .net core中若是配置了json数据源,把reloadOnChange属性设置为true便可实现当文件变动时自动更新配置,这篇博客咱们首先从它的源码简单看一下,看完你可能仍是会有点懵的,别慌,我会对这些代码进行精简,作个简单的小例子,但愿能对你有所帮助.git

一窥源码

AddJson

首先,咱们固然是从这个咱们耳熟能详的扩展函数开始,它经历的演变过程以下.程序员

public static IConfigurationBuilder AddJsonFile(this IConfigurationBuilder builder,string path,bool optional,bool reloadOnChange)
    {
      return builder.AddJsonFile((IFileProvider) null, path, optional, reloadOnChange);
    }

传递一个null的FileProvider给另一个重载Addjson函数.
敲黑板,Null的FileProvider很重要,后面要考😄.github

public static IConfigurationBuilder AddJsonFile(this IConfigurationBuilder builder,IFileProvider provider,string path,bool optional,bool reloadOnChange)
    {
      return builder.AddJsonFile((Action<JsonConfigurationSource>) (s =>
      {
        s.FileProvider = provider;
        s.Path = path;
        s.Optional = optional;
        s.ReloadOnChange = reloadOnChange;
        s.ResolveFileProvider();
      }));
    }

把传入的参数演变成一个Action委托给JsonConfigurationSource的属性赋值.sql

public static IConfigurationBuilder AddJsonFile(this IConfigurationBuilder builder, Action<JsonConfigurationSource> configureSource)
    {
      return builder.Add<JsonConfigurationSource>(configureSource);
    }

最终调用的builder.add (action)方法. json

public static IConfigurationBuilder Add<TSource>(this IConfigurationBuilder builder,Action<TSource> configureSource)where TSource : IConfigurationSource, new()
    {
      TSource source = new TSource();
      if (configureSource != null)
        configureSource(source);
      return builder.Add((IConfigurationSource) source);
    }

在Add方法里,建立了一个Source实例,也就是JsonConfigurationSource实例,而后把这个实例传为刚刚的委托,这样一来,咱们在最外面传入的"appsettings.json",optional:true,reloadOnChange:true参数就做用到这个示例上了.
最终,这个实例添加到builder中.那么builder又是什么?它能干什么?c#

ConfigurationBuild

前面说起的builder默认状况下是ConfigurationBuilder,我对它的进行了简化,关键代码以下.app

public class ConfigurationBuilder : IConfigurationBuilder
    {
        public IList<IConfigurationSource> Sources { get; } = new List<IConfigurationSource>();

        public IConfigurationBuilder Add(IConfigurationSource source)
        {
            Sources.Add(source);
            return this;
        }

        public IConfigurationRoot Build()
        {
            var providers = new List<IConfigurationProvider>();
            foreach (var source in Sources)
            {
                var provider = source.Build(this);
                providers.Add(provider);
            }
            return new ConfigurationRoot(providers);
        }
    }

能够看到,这个builder中有个集合类型的Sources,这个Sources能够保存任何实现了IConfigurationSource的Source,前面聊到的JsonConfigurationSource就是实现了这个接口,经常使用的还有MemoryConfigurationSource,XmlConfigureSource,CommandLineConfigurationSource等.ide

另外,它有一个很重要的build方法,这个build方法在WebHostBuilder方法执行build的时候也被调用,不要问我WebHostBuilder.builder方法什么执行的😂.函数

public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

在ConfigureBuilder的方法里面就调用了每一个Source的Builder方法,咱们刚刚传入的是一个JsonConfigurationSource,因此咱们有必要看看JsonSource的builder作了什么.
这里是否是被这些builder绕哭了? 别慌,下一篇文章中我会讲解如何自定义一个ConfigureSoure,会把Congigure系列类UML类图整理一下,应该会清晰不少.

JsonConfigurationSource

public class JsonConfigurationSource : FileConfigurationSource
    {
        public override IConfigurationProvider Build(IConfigurationBuilder builder)
        {
            EnsureDefaults(builder);
            return new JsonConfigurationProvider(this);
        }
    }

这就是JsonConfigurationSource的全部代码,未精简,它只实现了一个Build方法,在Build内,EnsureDefaults被调用,可别小看它,以前那个空的FileProvider在这里被赋值了.

public void EnsureDefaults(IConfigurationBuilder builder)
        {
            FileProvider = FileProvider ?? builder.GetFileProvider();
        }
        public static IFileProvider GetFileProvider(this IConfigurationBuilder builder)
        {
            return new PhysicalFileProvider(AppContext.BaseDirectory ?? string.Empty);
        }

能够看到这个FileProvider默认状况下就是PhysicalFileProvider,为何对这个FileProvider如此宠幸让我花如此大的伏笔要强调它呢?往下看.

JsonConfigurationProvider && FileConfigurationProvider

在JsonConfigurationSource的build方法内,返回的是一个JsonConfigurationProvider实例,因此直觉告诉我,在它的构造函数内必有猫腻😕.

public class JsonConfigurationProvider : FileConfigurationProvider
    {
       
        public JsonConfigurationProvider(JsonConfigurationSource source) : base(source) { }

      
        public override void Load(Stream stream)
        {
            try {
                Data = JsonConfigurationFileParser.Parse(stream);
            } catch (JsonReaderException e)
            {
                throw new FormatException(Resources.Error_JSONParseError, e);
            }
        }
    }

看不出什么的代码,事出反常必有妖~~
看看base的构造函数.

public FileConfigurationProvider(FileConfigurationSource source)
        {
            Source = source;

            if (Source.ReloadOnChange && Source.FileProvider != null)
            {
                _changeTokenRegistration = ChangeToken.OnChange(
                    () => Source.FileProvider.Watch(Source.Path),
                    () => {
                        Thread.Sleep(Source.ReloadDelay);
                        Load(reload: true);
                    });
            }
        }

真是个天才,问题就在这个构造函数里,它构造函数调用了一个ChangeToken.OnChange方法,这是实现ReloadOnChange的关键,若是你点到这里尚未关掉,恭喜,好戏开始了.

ReloadOnChange

Talk is cheap. Show me the code (屁话少说,放码过来).

public static class ChangeToken
    {
        public static ChangeTokenRegistration<Action> OnChange(Func<IChangeToken> changeTokenProducer, Action changeTokenConsumer)
        {
            return new ChangeTokenRegistration<Action>(changeTokenProducer, callback => callback(), changeTokenConsumer);
        }
    }

OnChange方法里,先无论什么func,action,就看看这两个参数的名称,producer,consumer,生产者,消费者,不知道看到这个关键词想到的是什么,反正我想到的是小学时学习食物链时的🐍与🐀.

那么咱们来看看这里的🐍是什么,🐀又是什么,还得回到FileConfigurationProvider的构造函数.

能够看到生产者🐀是:

() => Source.FileProvider.Watch(Source.Path)

消费者🐍是:

() => {
    Thread.Sleep(Source.ReloadDelay);
    Load(reload: true);
}

咱们想一下,一旦有一条🐀跑出来,就立马被🐍吃了,

那咱们这里也同样,一旦有FileProvider.Watch返回了什么东西,就会发生Load()事件来从新加载数据.

🐍与🐀好理解,但是代码就没那么好理解了,咱们经过OnChange的第一个参数Func<IChangeToken> changeTokenProducer方法知道,这里的🐀,实际上是IChangeToken.

IChangeToken

public interface IChangeToken
    {
        bool HasChanged { get; }

        bool ActiveChangeCallbacks { get; }

        IDisposable RegisterChangeCallback(Action<object> callback, object state);
    }

IChangeToken的重点在于里面有个RegisterChangeCallback方法,🐍吃🐀的这件事,就发生在这回调方法里面.
咱们来作个🐍吃🐀的实验.

实验1

static void Main()
        {
            //定义一个C:\Users\liuzh\MyBox\TestSpace目录的FileProvider
            var phyFileProvider = new PhysicalFileProvider("C:\\Users\\liuzh\\MyBox\\TestSpace");

            //让这个Provider开始监听这个目录下的全部文件
            var changeToken = phyFileProvider.Watch("*.*");

            //注册🐍吃🐀这件事到回调函数
            changeToken.RegisterChangeCallback(_=> { Console.WriteLine("老鼠被蛇吃"); }, new object());

            //添加一个文件到目录
            AddFileToPath();

            Console.ReadKey();

        }

        static void AddFileToPath()
        {
            Console.WriteLine("老鼠出洞了");
            File.Create("C:\\Users\\liuzh\\MyBox\\TestSpace\\老鼠出洞了.txt").Dispose();
        }

这是运行结果

能够看到,一旦在监听的目录下建立文件,当即触发了执行回调函数,可是若是咱们继续手动地更改(复制)监听目录中的文件,回调函数就再也不执行了.

这是由于changeToken监听到文件变动并触发回调函数后,这个changeToken的使命也就完成了,要想保持一直监听,那么咱们就在在回调函数中从新获取token,并给新的token的回调函数注册通用的事件,这样就能保持一直监听下去了.
这也就是ChangeToken.Onchange所做的事情,咱们看一下源码.

public static class ChangeToken
    {
        public static ChangeTokenRegistration<Action> OnChange(Func<IChangeToken> changeTokenProducer, Action changeTokenConsumer)
        {
            return new ChangeTokenRegistration<Action>(changeTokenProducer, callback => callback(), changeTokenConsumer);
        }
    }
    public class ChangeTokenRegistration<TAction>
    {
        private readonly Func<IChangeToken> _changeTokenProducer;
        private readonly Action<TAction> _changeTokenConsumer;
        private readonly TAction _state;

        public ChangeTokenRegistration(Func<IChangeToken> changeTokenProducer, Action<TAction> changeTokenConsumer, TAction state)
        {
            _changeTokenProducer = changeTokenProducer;
            _changeTokenConsumer = changeTokenConsumer;
            _state = state;

            var token = changeTokenProducer();

            RegisterChangeTokenCallback(token);
        }

        private void RegisterChangeTokenCallback(IChangeToken token)
        {
            token.RegisterChangeCallback(_ => OnChangeTokenFired(), this);
        }

        private void OnChangeTokenFired()
        {
            var token = _changeTokenProducer();

            try
            {
                _changeTokenConsumer(_state);
            }
            finally
            {
                // We always want to ensure the callback is registered
                RegisterChangeTokenCallback(token);
            }
        }
    }

简单来讲,就是给token注册了一个OnChangeTokenFired的回调函数,仔细看看OnChangeTokenFired里作了什么,整体来讲三步.

获取一个新的token.
调用消费者进行消费.
给新获取的token再次注册一个OnChangeTokenFired的回调函数.

如此周而复始~~

实验2

既然知道了OnChange的工做方式,那么咱们把实验1的代码修改一下.

static void Main()
        {
            var phyFileProvider = new PhysicalFileProvider("C:\\Users\\liuzh\\MyBox\\TestSpace");
            ChangeToken.OnChange(() => phyFileProvider.Watch("*.*"),
                () => { Console.WriteLine("老鼠被蛇吃"); });
            Console.ReadKey();
        }

执行效果看一下

能够看到,只要被监控的目录发生了文件变化,不论是新建文件,仍是修改了文件内的内容,都会触发回调函数,其实JsonConfig中,这个回调函数就是Load(),它负责从新加载数据,可也就是为何Asp .net core中若是把ReloadOnchang设置为true后,Json的配置一旦更新,配置就会自动重载.

PhysicalFilesWatcher

那么,为何文件一旦变化,就会触发ChangeToken的回调函数呢? 其实PhysicalFileProvider中调用了PhysicalFilesWatcher对文件系统进行监视,观察PhysicalFilesWatcher的构造函数,能够看到PhysicalFilesWatcher须要传入FileSystemWatcher,FileSystemWatcher是system.io下的底层IO类,在构造函数中给这个Watcher的Created,Changed,Renamed,Deleted注册EventHandler事件,最终,在这些EventHandler中会调用ChangToken的回调函数,因此文件系统一旦发生变动就会触发回调函数.

public PhysicalFilesWatcher(string root,FileSystemWatcher fileSystemWatcher,bool pollForChanges,ExclusionFilters filters)
    {
      this._root = root;
      this._fileWatcher = fileSystemWatcher;
      this._fileWatcher.IncludeSubdirectories = true;
      this._fileWatcher.Created += new FileSystemEventHandler(this.OnChanged);
      this._fileWatcher.Changed += new FileSystemEventHandler(this.OnChanged);
      this._fileWatcher.Renamed += new RenamedEventHandler(this.OnRenamed);
      this._fileWatcher.Deleted += new FileSystemEventHandler(this.OnChanged);
      this._fileWatcher.Error += new ErrorEventHandler(this.OnError);
      this.PollForChanges = pollForChanges;
      this._filters = filters;
      this.PollingChangeTokens = new ConcurrentDictionary<IPollingChangeToken, IPollingChangeToken>();
      this._timerFactory = (Func<Timer>) (() => NonCapturingTimer.Create(new TimerCallback(PhysicalFilesWatcher.RaiseChangeEvents), (object) this.PollingChangeTokens, TimeSpan.Zero, PhysicalFilesWatcher.DefaultPollingInterval));
    }

蒋金楠老师有一篇优秀的文章介绍FileProvider,有兴趣的能够看一下
https://www.cnblogs.com/artech/p/net-core-file-provider-02.html.

若是你和我同样,对源码感兴趣,能够从官方的aspnet/Extensions中下载源码研究:https://github.com/aspnet/Extensions

在下一篇文章中,我会讲解如何自定义一个以Mysql为数据源的ConfigureSoure,并实现自动更新功能,同时还会整理Configure相关类的UML类图,有兴趣的能够关注我以便第一时间收到下篇文章.
本文章涉及的代码地址:https://github.com/liuzhenyulive/MiniConfiguration