登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›.NET 高级开发 | 配置系统原理、实现一个配置中心 ...

.NET 高级开发 | 配置系统原理、实现一个配置中心

蝓俟佐 9 小时前
程序园永久vip申请，无限下载程序园所有程序/软件/数据/等
目录

  • 配置和选项



      • 配置(Configuration)

        • 读取配置
        • 配置拦截
        • 配置优先级

      • 选项(Options)
      • 实现自定义配置提供器
      • 实现配置中心



配置和选项

ASP.NET Core 模板项目下会有 appsettings.json、appsettings.Development.json 两个配置文件，我们可以通过这两个文件配置 Web 应用的启动端口、是否使用 https 等，大多数第三方框架也都支持在这两个 json 文件中配置。ASP.NET Core 程序默认支持从 json 文件、xml 文件、环境变量等多种配置源注入到内存中，微服务应用一般会使用远程配置中心存储配置以便动态更新到程序中，不管是什么类型的配置源，只需要提供 IConfigurationBuilder 的扩展方法给开发者即可，开发者不必关注配置源本身的实现细节。而 Microsoft.Extensions.Configuration.Abstractions 定义了统一的接口，使用者只需要 注入 IConfiguration 服务即可动态获取配置。
在实际生产环境中，尤其在微服务场景下，我们会有实时更新配置的需求，要求服务实例使用集中式的配置中心，以便修改配置后所有实例同时更新。通过配置中心管理多个服务的配置，以及将实例的开发、测试等环境的配置隔离开来。在本章中，笔者将会介绍这些 .NET 中的配置和选项，在学会使用方法和原理之后，还会介绍如何使用 SignalR 开发一个配置中心，不管使用的是控制台还是例如 WPF 这类桌面程序，都可以达到 ASP.NET Core 中使用配置的效果。
在本小节中，我们将会做两个实践项目，第一个是实现从文件中读取配置，并且在文件修改后能够实时更新配置到内存中；第二个是实现一个配置中心，能够将远程配置更新到本地。
配置(Configuration)

创建一个控制台程序，然后引入 Microsoft.Extensions.Configuration 类库，我们可以使用 ConfigurationBuilder 类构建配置提供器，然后通过扩展包从各种数据源中导入配置。
目前，Microsoft 官方提供的导入配置源扩展方法有以下类型：

  • 内存键值集合
  • 配置文件，json、xml、yaml 文件等
  • 环境变量、命令行参数
无论是哪种数据源，导入到内存中时，均以字符串键值对的形式出现。
从 json 文件获取配置，需要引入 Microsoft.Extensions.Configuration.Json 包。
在项目根目录下创建一个 json 文件，内容如下：
  1. {
  2. "test":"配置"
  3. }
复制代码
然后从 json 中导入配置。
  1.             var config = new ConfigurationBuilder()
  2.                 .AddJsonFile("test.json")
  3.                 .Build();
  4.             string test = config["test"];
  5.             Console.WriteLine(test);
复制代码
如果配置文件不在根目录下，则可以使用 SetBasePath() 来定义路径，示例如下：
  1.             var config = new ConfigurationBuilder()
  2.                 .SetBasePath("E:\\test\\aaa")
  3.                 .AddJsonFile("test.json")
  4.                 .Build();
复制代码
另外，json 扩展默认会监听文件的变化，如果文件做出了修改，那么就会重新读取配置到内存中。
  1.                 config.AddJsonFile("appsettings.json",
  2.                     optional: true,
  3.                     reloadOnChange: true);
复制代码
而从键值对计划中导入配置，示例如下：
  1.         var dic = new Dictionary<string, string>()
  2.         {
  3.             ["test"] = "配置"
  4.         };
  5.         var config = new ConfigurationBuilder()
  6.             .AddInMemoryCollection(dic)
  7.             .Build();
  8.         string test = config["test"];
复制代码
常用的导入配置的扩展方法有：
  1. builder.Configuration
  2.     .AddCommandLine(...)
  3.     .AddEnvironmentVariables(...)
  4.     .AddIniFile(...)
  5.     .AddIniStream(...)
  6.     .AddInMemoryCollection(...)
  7.     .AddJsonFile(...)
  8.     .AddJsonStream(...)
  9.     .AddKeyPerFile(...)
  10.     .AddUserSecrets(...)
  11.     .AddXmlFile(...)
  12.     .AddXmlStream(...);
复制代码
观察 AddInMemoryCollection() 的扩展方法，可以看到本质是创建了一个 MemoryConfigurationSource 实例，添加到 IConfigurationBuilder 中。
  1.         public static IConfigurationBuilder AddInMemoryCollection(this IConfigurationBuilder configurationBuilder)
  2.         {
  3.             ThrowHelper.ThrowIfNull(configurationBuilder);
  5.             configurationBuilder.Add(new MemoryConfigurationSource());
  6.             return configurationBuilder;
  7.         }
复制代码
如果我们要自定义一个数据源，需要实现 IConfigurationSource、IConfigurationProvider 两个接口，IConfigurationSource 用于生成配置提供器，IConfigurationProvider 用于通过 key 获取配置字符串。
  1.     public interface IConfigurationSource
  2.     {
  3.         IConfigurationProvider Build(IConfigurationBuilder builder);
  4.     }
复制代码
  1.     public interface IConfigurationProvider
  2.     {
  3.         bool TryGet(string key, out string? value);
  4.         void Set(string key, string? value);
  5.         IChangeToken GetReloadToken();
  6.         void Load();
  7.         IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string? parentPath);
  8.     }
复制代码
读取配置

在 ASP.NET Core 项目中，都会有个 appsettings.json 文件，其默认内容如下：
  1. {
  2.   "Logging": {
  3.     "LogLevel": {
  4.       "Default": "Information",
  5.       "Microsoft": "Warning",
  6.       "Microsoft.Hosting.Lifetime": "Information"
  7.     }
  8.   }
  9. }
复制代码
因为配置在内存中是以键值对出现的，我们可以使用 : 符号获取下一层子项的配置。
  1.             var config = new ConfigurationBuilder()
  2.                 .AddJsonFile("appsettings.json")
  3.                 .Build();
  5.             string test = config["Logging:LogLevel:Default"];
复制代码
1.png

查找 LoggingogLevelefault 时，并不需要先定位 Logging 再往下查找 LogLevel ，而是直接使用字符串 LoggingogLevelefault 作为 Key 从配置字典中查询对应的 Value。
  1. "Logging:LogLevel:Default" = "Information"
  2. "Logging:LogLevel:Microsoft" = "Warning"
复制代码
通过 json 配置文件，我们可以很方便地构建层级结构的配置，如果想在字典中存储，可以使用 "{k1}:{k2}" 这种形式存。例如：
  1.             var dic = new Dictionary<string, string>()
  2.             {
  3.                 ["testParent:Child1"] = "6",
  4.                 ["testParent:Child2"] = "666"
  5.             };
  6.             var config = new ConfigurationBuilder()
  7.                 .AddInMemoryCollection(dic)
  8.                 .Build().GetSection("testParent");
  10.             string test = config["Child1"];
复制代码
如果你只想 获取 json 文件中 LogLevel 部分的配置，可以使用 GetSection() 方法获取 IConfigurationSection 对象，这样可以筛选出以当前字符串开头的所有配置，那么我们下次使用时，就不必提供完整的 Key 了。
  1. // json:
  2. {
  3.   "Logging": {
  4.     "LogLevel": {
  5.       "Default": "Information",
  6.       "Microsoft.AspNetCore": "Warning"
  7.     }
  8.   },
  9.   "AllowedHosts": "*"
  10. }
  12. // C#
  13. varconfig = new ConfigurationBuilder()
  14.     .AddJsonFile("appsettings.json")
  15.     .Build();
  17. IConfigurationSection section = config.GetSection("Logging:LogLevel");
  18. string test = section["Default"];
复制代码
但是这样读取起来很不方便，我们可以使用 Microsoft.Extensions.Configuration.Binder 类库，里面有大量的扩展方法，可以帮助我们将配置字符串转换为强类型。
  1. // json:
  2. {
  3.   "test": {
  4.     "Index": 1
  5.   }
  6. }
  9. // C#:
  10. public class Test
  11. {
  12.         public int Index { get; set; }
  13. }
  15. var config = new ConfigurationBuilder()
  16.         .AddJsonFile("test.json")
  17.     .Build();
  18. var section = config.GetSection("test");
  19. var o = section.Get<Test>();
复制代码
即使源数据没有层次结构，我们可以也可以使用 Get() 方法将配置映射为对象。
  1.     public class TestOptions
  2.     {
  3.         public string A { get; set; }
  4.         public string B { get; set; }
  5.         public string C { get; set; }
  6.     }
复制代码
  1.             var dic = new Dictionary<string, string>()
  2.             {
  3.                 ["A"] = "6",
  4.                 ["B"] = "66",
  5.                 ["C"] = "666"
  6.             };
  7.             TestOptions config = new ConfigurationBuilder()
  8.                 .AddInMemoryCollection(dic)
  9.                 .Build().Get<TestOptions>();
复制代码
配置拦截

有时，从数据源中导入的配置是第三方扩展提供的，有些配置无法直接修改，因为所有的配置都会以键值对的形式存储在内存中，那么我们可以尝试通过增加配置键值对来解决这个问题。
比如 Serilog 的配置，Serilog 可以在配置文件中设置打印文件日志，我们需要在程序运行时确定日志存放到哪里。
  1.     public static void DynamicLog(this IServiceCollection services, string customPath)
  2.     {
  3.         var configuration = services!.BuildServiceProvider().GetRequiredService<IConfiguration>();
  5.                 // 查找节点
  6.         var fileName = configuration.AsEnumerable()
  7.             .Where(x => x.Key.StartsWith("Serilog:WriteTo") && x.Key.EndsWith("Name") && x.Value!.Equals("File")).FirstOrDefault();
  9.         // Serilog:WriteTo:0:Name
  10.         if (!string.IsNullOrEmpty(fileName.Value))
  11.         {
  12.             var key = fileName.Key.Replace("Name", "Args:path");
  13.             var path = Path.Combine(customPath, "log.txt");
  14.             configuration[key] = path;
  15.         }
  16.     }
复制代码
配置优先级

在 ASP.NET Core 中，开发时会使用到 appsettings.json、appsettings.Development.json 配置文件，这两个配置文件都有自己的 IConfigurationSource、IConfigurationProvider。
运行时，appsettings.Development.json 中的配置会替换 appsettings.json 的配置。
其实在于配置的注入顺序，例如我们可以手动注入多个 json 配置文件：
  1. var configuration = new ConfigurationBuilder()
  2. .AddJsonFile(path: "appsettings.json")
  3. .AddJsonFile(path: "appsettings.Development.json")
复制代码
这个 Configuration 会存在两个配置源：
  1. // appsettings.json
  2. JsonConfigurationSource
  3. // appsettings.Development.json
  4. JsonConfigurationSource
复制代码
当查找配置时，会从 Providers 中倒序查找，会首先从 appsettings.Development.json 中查找配置，当查找完成后，立即返回。
因此，当我们需要使用自定义配置提供器时，可以在最后才加上我们的提供器，这样我们自定义的提供器优先级最高。
选项(Options)

在 ASP.NET Core 中，很多中间件的配置是通过选项传递的。比如设置表单上传文件最大为 30MB。
  1. // 表单配置
  2. builder.Services.Configure<FormOptions>(options =>
  3. {
  4.     // 上传的文件最大为 30mb
  5.     options.MultipartBodyLengthLimit = 31_457_280;
  6. });
复制代码
这样做的好处是，我们使用配置时，可以直接使用强类型，而不需要关注如何从 IConfiguration 中取出配置。
如果我们要获取 TestOptions，是通过 IOptions 来获取的，不能直接获取 TestOptions 服务。
  1.         private readonly TestModel _options;
  2.         public TestController(IOptions<FormOptions> options)
  3.         {
  4.             _options = options.Value;
  5.         }
复制代码
配置和选项的最重要差别是，配置是用于整个程序，以键值对的形式存储信息，而选项是给特定模块提供参数，使用强类型。
示例项目在 Demo3.Options
我们创建一个控制台项目，引入以下包：
  1.         <ItemGroup>
  2.                 <PackageReference Include="Microsoft.Extensions.Configuration" Version="7.0.0" />
  3.                 <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
  4.                 <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
  5.                 <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="7.0.0" />
  6.         </ItemGroup>
复制代码
添加一个 test.json 文件，内容如下：
  1. {
  2.   "Title": "测试",
  3.   "Name": "测试测试"
  4. }
复制代码
再创建一个与之对应的模型类：
  1.     public class TestOptions
  2.     {
  3.         public string Title { get; set; }
  4.         public string Name { get; set; }
  5.     }
复制代码
选项接口主要有三个接口，分别是：

  • IOptions
  • IOptionsSnapshot
  • IOptionsMonitor
.NET 8 有了新的变化。
使用示例如下：
  1.         static void Main(string[] args)
  2.         {
  3.             var services = new ServiceCollection();
  4.             var configuration = new ConfigurationBuilder()
  5.                 .AddJsonFile("test.json", optional: true, reloadOnChange: true)
  6.                 .Build();
  7.             services.AddSingleton<IConfiguration>(configuration);
  9.             services.AddOptions<TestOptions>().Bind(configuration);
  10.             // services.Configure<TestOptions>(name: "", configuration);
  11.             // 或者使用 Microsoft.Extensions.Options.ConfigurationExtensions 包
  12.             // services.Configure<TestOptions>(configuration);
  14.             var ioc = services.BuildServiceProvider();
  15.             var to1 = ioc.GetRequiredService<IOptions<TestOptions>>();
  16.             var to2 = ioc.GetRequiredService<IOptionsSnapshot<TestOptions>>();
  17.             var to3 = ioc.GetRequiredService<IOptionsMonitor<TestOptions>>();
  18.             to3.OnChange(s =>
  19.             {
  20.                 Console.WriteLine($"变更之前的值: {s.Name}");
  21.             });
  22.             while (true)
  23.             {
  24.                 Console.WriteLine($"IOptions: {to1.Value.Name}");
  25.                 Console.WriteLine($"IOptionsSnapshot: {to2.Value.Name}");
  26.                 Console.WriteLine($"IOptionsMonitor: {to3.CurrentValue.Name}");
  27.                 Thread.Sleep(1000);
  28.             }
  29.         }
复制代码
我们可以手动修改 test.json 文件，观察控制台打印。
这三种方式都可以获取到选项，它们之间的区别在于生命周期和文件监控等。
ASP.NET Core 源代码：
  1.             services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptions<>), typeof(UnnamedOptionsManager<>)));
  2.             services.TryAdd(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot<>), typeof(OptionsManager<>)));
  3.             services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitor<>), typeof(OptionsMonitor<>)));
  4.             services.TryAdd(ServiceDescriptor.Transient(typeof(IOptionsFactory<>), typeof(OptionsFactory<>)));
  5.             services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitorCache<>), typeof(OptionsCache<>)));
复制代码
IOptions 有以下特征：
注册为单一实例且可以注入到任何服务生存期。
不支持在应用启动后读取配置数据。也就是说即使配置源可以动态更新，但是 IOptions 不会动态从 IConfiguration 中 最新的配置。
也就是说，在应用启动前就已经读取配置文件生成对象(单一实例)。当然，后续如果修改了配置文件(.json)，也不会影响这个对象的。
文档解释：通过使用 IOptionsSnapshot，针对请求生存期访问和缓存选项时，每个请求都会计算一次选项。
IOptionsSnapshot 的生命作用域是 scoped ，在一个请求周期内有效，而 IOptionsMonitor 是单例模式，但是却可以监听配置的变更。
由于 IOptionsSnapshot 每次请求都会进行更新，因此配置文件变更后，可以及时获得更新。
IOptionsMonitor 则略有不同。IOptionsSnapshot 和 IOptionsMonitor 都可以检测到配置文件的更改，但是 IOptionsSnapshot 每次请求都是一个新的对象，在同一个请求上下文中同一个对象。而 IOptionsMonitor 是单例模式，主要用于结合 IConfiguration 使用。
但是要注意，要使用 IOptionsMonitor  很多写法是无效的。比如：
  1.             services.Configure<TestOptions>(o =>
  2.             {
  3.                 o.Name = new Random().Next(0, 100).ToString();
  4.             });
  5.             services.Configure<TestOptions>(o =>
  6.             {
  7.                 configuration.Bind(o);
  8.             });
复制代码
实现自定义配置提供器

在本节中，笔者将会介绍如何编写一个从文件导入的配置提供器，并且实现随文件变化动态更新到内存中。
代码示例在 Demo4.Console 中。
引入 Microsoft.Extensions.FileProviders.Physical ，用于监听目录、文件变化。
我们将来实现读取自定义配置格式的文件，创建一个 env.conf 文件，内容如下：
  1. A:111
  2. B:222
复制代码
配置文件通过 : 号来分隔 key 和 value，
我们要实现自定义配置提供器，需要先编写一个配置源，需要继承 IConfigurationSource 接口，其接口定义非常简单：
  1.         public interface IConfigurationSource
  2.         {
  3.                 IConfigurationProvider Build(IConfigurationBuilder builder);
  4.         }
复制代码
创建一个 MyConfigurationSource 类型，代码如下：
  1.     public class MyConfigurationSource : IConfigurationSource
  2.     {
  3.         // 配置文件的路径
  4.         public string Path { get; set; }
  5.         // 是否实时监听此文件变化
  6.         public bool ReloadOnChange { get; set; }
  7.         public IConfigurationProvider Build(IConfigurationBuilder builder)
  8.         {
  9.             return new MyConfigurationProvider(this);
  10.         }
  11.     }
复制代码
接着定义配置提供器，配置提供器需要存储配置信息，提供配置查询等接口。
代码示例如下：
  1. public class MyConfigurationProvider : IConfigurationProvider
  2. {
  3.         private readonly MyConfigurationSource _source;
  4.         private readonly IFileProvider _fileProvider;
  6.         private readonly string _path;
  7.         private readonly string _fileName;
  9.     // 缓存
  10.         private readonly Dictionary<string, string> _cache;
  11.    
  12.         public MyConfigurationProvider(MyConfigurationSource source)
  13.         {
  14.                 _source = source;
  15.                 _cache = new Dictionary<string, string>();
  16.        
  17.                 _path = Directory.GetParent(_source.Path)!.FullName;
  18.                 _fileName = Path.GetFileName(_source.Path);
  20.                 _fileProvider = new PhysicalFileProvider(_path);
  21.                 if (_source.ReloadOnChange)
  22.                 {
  23.             // 监听配置文件变化
  24.                         ChangeToken.OnChange(() => _fileProvider.Watch(_fileName), async () => await ReloadFileAsync());
  25.                 }
  26.                 else
  27.                 {
  28.                         ReloadFileAsync().Wait();
  29.                 }
  30.         }
  31.    
  32.         // 重新加载配置文件到内存中
  33.         private async Task ReloadFileAsync()
  34.         {
  35.                 using var stream = _fileProvider.GetFileInfo(_fileName).CreateReadStream();
  36.                 using var streamReader = new StreamReader(stream);
  37.                 _cache.Clear();
  38.                 while (true)
  39.                 {
  40.                         var line = await streamReader.ReadLineAsync();
  41.                         if (line == null) break;
  42.                         var kv = line.Split(':')[0..2].Select(x => x.Trim(' ')).ToArray();
  43.                         _cache.Add(kv[0], kv[1]);
  44.                 }
  45.         }
  47.         public IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string? parentPath) => _cache.Keys;
  49.         public IChangeToken GetReloadToken() => null;
  51.         public void Load()
  52.         {
  53.                 ReloadFileAsync().Wait();
  54.         }
  56.         public void Set(string key, string? value)
  57.         {
  58.                 _cache[key] = value!;
  59.         }
  61.         public bool TryGet(string key, out string? value)
  62.         {
  63.                 return _cache.TryGetValue(key, out value);
  64.         }
  65. }
复制代码
接着定义扩展，以便支持外部依赖注入：
  1. public static class Extensions
  2. {
  3.     public static IConfigurationBuilder AddEnvFile(this IConfigurationBuilder builder, string path, bool reloadOnChange = false)
  4.     {
  5.         var source = new MyConfigurationSource()
  6.         {
  7.             Path = path,
  8.             ReloadOnChange = reloadOnChange
  9.         };
  10.         builder.Add(source);
  11.         return builder;
  12.     }
  13. }
复制代码
然后使用我们自定义的配置提供器：
  1.         static void Main()
  2.         {
  3.                 var configuration = new ConfigurationBuilder()
  4.                         .AddEnvFile("env.conf", true)
  5.                         .Build();
  6.                 while (true)
  7.                 {
  8.                         var value = configuration["A"];
  9.                         Console.WriteLine($"A = {value}");
  10.                         Thread.Sleep(1000);
  11.                 }
  12.         }
复制代码
启动程序后，修改程序运行目录下的 env.conf 文件，查看控制台中的输出，检查控制台的输出是否与修改后的文件一致。
实现配置中心

在了解配置、选项的使用方法，以及如何自定义配置提供器之后，在本小节，我们将会创建一个配置中心服务，然后客户端通过 SignalR 与配置中心通讯，当配置中心的配置内容被修改后，自动推送到客户端中。
新建一个名为 Demo3.ConfigCenter 的 API 项目和一个名为 Demo3.ConfigClient 的控制台项目。
首先是实现配置中心的 Demo3.ConfigCenter 的代码，创建一个保存客户端信息的模型类。
  1.     /// <summary>
  2.     /// 客户端的信息
  3.     /// </summary>
  4.     public class ClientInfo
  5.     {
  6.         /// <summary>
  7.         /// SignalR 连接的 id
  8.         /// </summary>
  9.         public string ConnectionId { get; set; }
  11.         /// <summary>
  12.         /// 应用名称
  13.         /// </summary>
  14.         public string AppName { get; set; }
  16.         /// <summary>
  17.         /// 命名空间
  18.         /// </summary>
  19.         public string Namespace { get; set; }
  21.         /// <summary>
  22.         /// 分组名称
  23.         /// </summary>
  24.         public string GroupName => $"{AppName}-{Namespace}";
  26.         /// <summary>
  27.         /// 客户端的 IP 地址
  28.         /// </summary>
  29.         public string IpAddress { get; set; }
  30.     }
复制代码
创建一个用于 SignalR 通讯的 Hub 服务，与客户端进行实时通信。
  1.     public partial class ConfigCenterHub : Hub
  2.     {
  3.         // 客户端连接信息
  4.         private static readonly ConcurrentDictionary<string, ClientInfo> _clients = new();
  5.         // 在内存中保存每个服务的配置
  6.         private static readonly ConcurrentDictionary<string, JsonObject> _settings = new();
  8.         private readonly IHubContext<ConfigCenterHub> _hubContext;
  9.         public ConfigCenterHub(IHubContext<ConfigCenterHub> hubContext)
  10.         {
  11.             _hubContext = hubContext;
  12.         }
  14.         // 当客户端连接到服务时
  15.         public override async Task OnConnectedAsync()
  16.         {
  17.             ClientInfo clientnInfo = GetInfo();
  19.             await _hubContext.Groups.AddToGroupAsync(clientnInfo.ConnectionId, clientnInfo.GroupName);
  20.             _clients[clientnInfo.GroupName] = clientnInfo;
  21.         }
  23.         // 当客户端断开服务时
  24.         public override async Task OnDisconnectedAsync(Exception? exception)
  25.         {
  26.             ClientInfo clientnInfo = GetInfo();
  28.             await _hubContext.Groups.RemoveFromGroupAsync(clientnInfo.ConnectionId, clientnInfo.GroupName);
  29.             _clients.TryRemove(clientnInfo.ConnectionId, out _);
  30.         }
  32.         // 获取客户端的信息
  33.         private ClientInfo GetInfo()
  34.         {
  35.             var feature = Context.Features.Get<IHttpConnectionFeature>();
  36.             var httpContext = Context.GetHttpContext();
  38.             ArgumentNullException.ThrowIfNull(feature);
  39.             ArgumentNullException.ThrowIfNull(httpContext);
  41.             // 从 header 中查询信息
  42.             var appName = httpContext.Request.Headers["AppName"].FirstOrDefault();
  43.             var namespaceName = httpContext.Request.Headers["Namespace"].FirstOrDefault();
  45.             ArgumentNullException.ThrowIfNull(appName);
  46.             ArgumentNullException.ThrowIfNull(namespaceName);
  48.             var groupName = $"{appName}-{namespaceName}";
  50.             // 获取客户端通讯地址
  51.             var remoteAddress = feature.RemoteIpAddress;
  52.             ArgumentNullException.ThrowIfNull(remoteAddress);
  53.             var remotePort = feature.RemotePort;
  55.             return new ClientInfo
  56.             {
  57.                 ConnectionId = feature.ConnectionId,
  58.                 AppName = appName,
  59.                 Namespace = namespaceName,
  60.                 IpAddress = $"{remoteAddress.MapToIPv4().ToString()}:{remotePort}"
  61.             };
  62.         }
  63.         
  64.         // 客户端自行获取配置
  65.         public async Task<JsonObject> GetAsync()
  66.         {
  67.             ClientInfo clientnInfo = GetInfo();
  68.             if(_settings.TryGetValue(clientnInfo.GroupName, out var v))
  69.             {
  70.                 return v;
  71.             }
  72.             var dic = new Dictionary<string, JsonNode>().ToList();
  73.             return new JsonObject(dic);
  74.         }
  75.         
  76.         // 更新缓存
  77.         public void UpdateCache(string appName, string namespaceName, JsonObject json)
  78.         {
  79.             var groupName = $"{appName}-{namespaceName}";
  80.             _settings[groupName] = json;
  81.         }
  82.     }
复制代码
然后注册 Hub 服务：
  1. ... ...
  2. builder.Services.AddSwaggerGen();
  4. // 注入 SignalR
  5. builder.Services.AddSignalR();
  6. builder.Services.AddScoped<ConfigCenterHub>();
  8. var app = builder.Build();
  10. ... ...
  11. app.MapControllers();
  13. // 加入 Hub 中间件
  14. app.MapHub<ConfigCenterHub>("/config");
  15. app.Run("http://*:5000");
复制代码
创建一个 ConfigController 控制器，允许通过 API 修改配置中心的内容，以及在修改配置后推送到对应的客户端中。
  1.     [ApiController]
  2.     [Route("[controller]")]
  3.     public class ConfigController : ControllerBase
  4.     {
  5.         private readonly ConfigCenterHub _configCenter;
  6.         private readonly IHubContext<ConfigCenterHub> _hubContext;
  8.         public ConfigController(IHubContext<ConfigCenterHub> hubContext, ConfigCenterHub configCenter)
  9.         {
  10.             _hubContext = hubContext;
  11.             _configCenter = configCenter;
  12.         }
  14.         [HttpPost("update")]
  15.         public async Task<string> Update(string appName, string namespaceName, [FromBody] JsonObject json)
  16.         {
  17.             var groupName = $"{appName}-{namespaceName}";
  18.             _configCenter.UpdateCache(appName, namespaceName, json);
  19.             await _hubContext.Clients.Group(groupName).SendAsync("Publish", json);
  20.             return "已更新配置";
  21.         }
  22.     }
复制代码
接下来就是客户端部分。
在程序启动时，会读取目录的 tmp_config.json 文件注入到配置中，如果文件不存在则创建。然后使用框架自带的 JsonConfigurationProvider 为我们动态监听 json 文件的变化，减少我们的代码量。在实时监听 Json 文件变化，以及解析 json ，这部分可以利用官方的 JsonConfigurationSource 来实现，我们就不需要重新写一个了。
然后使用 SignalR 与配置中心通讯，将配置中心的内容写入到临时文件 tmp_config.json 中，JsonConfigurationProvider 会自动将修改后的 json 文件加载到内存中。因为我们使用了本地配置文件，获取到的配置先缓存在本地中，所以当下次程序启动时或网络出现故障时，程序依然可以通过本地缓存配置启动起来。这个也是很多配置中心都有实现的。
在  Demo3.ConfigClient 中创建 OnlineConfigurationSource、OnlineConfigurationProvider 文件，写入以下代码：
  1.     public class OnlineConfigurationSource : IConfigurationSource
  2.     {
  3.         /// <summary>
  4.         /// 获取最新配置的 API 路径
  5.         /// </summary>
  6.         public string URL { get; init; }
  7.         public string AppName { get; init; }
  8.         public string Namespace { get; init; }
  10.         public IConfigurationProvider Build(IConfigurationBuilder builder)
  11.         {
  12.             return new OnlineConfigurationProvider(this, builder);
  13.         }
  14.     }
复制代码
然后实现一个配置提供器，与 Hub 服务器实时通信，并更新到 tmp_config.json 文件中。
  1.     public class OnlineConfigurationProvider : IConfigurationProvider, IDisposable
  2.     {
  3.         private const string TmpFile = "tmp_config.json";
  4.         private readonly string _jsonPath;
  6.         private readonly OnlineConfigurationSource _configurationSource;
  7.         private readonly JsonConfigurationSource _jsonSource;
  8.         private readonly IConfigurationProvider _provider;
  9.         private readonly HubConnection _connection;
  11.         public OnlineConfigurationProvider(OnlineConfigurationSource configurationSource, IConfigurationBuilder builder)
  12.         {
  13.             // 使用框架自带的 JsonConfigurationSource 动态获取 json 文件的内容
  14.             var curPath = Directory.GetParent(typeof(OnlineConfigurationProvider).Assembly.Location).FullName;
  15.             _jsonPath = Path.Combine(curPath, TmpFile);
  16.             if (!File.Exists(TmpFile)) File.WriteAllText(_jsonPath, "{}");
  18.             _configurationSource = configurationSource;
  19.             _jsonSource = new JsonConfigurationSource()
  20.             {
  21.                 Path = TmpFile,
  22.                 ReloadOnChange = true,
  23.             };
  24.             _provider = _jsonSource.Build(builder);
  26.             // 配置 SignalR 通讯，将新的内容写入到 json 文件
  27.             _connection = new HubConnectionBuilder()
  28.                 .WithUrl(_configurationSource.URL, options =>
  29.                 {
  30.                     options.Headers.Add("AppName", _configurationSource.AppName);
  31.                     options.Headers.Add("Namespace", _configurationSource.Namespace);
  32.                 })
  33.                 .WithAutomaticReconnect()
  34.                 .Build();
  36.             _connection.On<JsonObject>("Publish", async (json) =>
  37.             {
  38.                 await SaveJsonAsync(json);
  39.             });
  41.             _connection.StartAsync().Wait();
  42.             var json = _connection.InvokeAsync<JsonObject>("GetAsync").Result;
  43.             SaveJsonAsync(json).Wait();
  44.         }
  46.         private async Task SaveJsonAsync(JsonObject json)
  47.         {
  48.             // 每次清空文件重新写入内容
  49.             using FileStream fs = new FileStream(_jsonPath, FileMode.Truncate, FileAccess.ReadWrite);
  50.             await System.Text.Json.JsonSerializer.SerializeAsync(fs, json);
  51.             Console.WriteLine($"已更新配置：{System.Text.Json.JsonSerializer.Serialize(json)}");
  52.         }
  54.         private bool _disposedValue;
  55.         ~OnlineConfigurationProvider() => Dispose(false);
  56.         public void Dispose()
  57.         {
  58.             Dispose(true);
  59.             GC.SuppressFinalize(this);
  60.         }
  62.         protected virtual void Dispose(bool disposing)
  63.         {
  64.             if (!_disposedValue)
  65.             {
  66.                 if (disposing)
  67.                 {
  68.                     _connection.DisposeAsync();
  69.                 }
  70.                 _disposedValue = true;
  71.             }
  72.         }
  74.         public IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string? parentPath) => _provider.GetChildKeys(earlierKeys, parentPath);
  75.         public IChangeToken GetReloadToken() => _provider.GetReloadToken();
  76.         public void Load() => _provider.Load();
  77.         public void Set(string key, string? value) => _provider.Set(key, value);
  78.         public bool TryGet(string key, out string? value) => _provider.TryGet(key, out value);
  79.     }
复制代码
编写扩展方法，配置 Hub 服务。
  1.     public static class Extensions
  2.     {
  3.         // 添加远程配置
  4.         public static IConfigurationBuilder AddReomteConfig(this IConfigurationBuilder builder, string url, string appName, string @namespace)
  5.         {
  6.             var source = new OnlineConfigurationSource()
  7.             {
  8.                 URL = url,
  9.                 AppName = appName,
  10.                 Namespace = @namespace
  11.             };
  12.             builder.Add(source);
  13.             return builder;
  14.         }
  15.     }
复制代码
使用配置中心服务：
  1.     internal class Program
  2.     {
  3.         static void Main(string[] args)
  4.         {
  5.             Thread.Sleep(5000);
  6.             var builder = new ConfigurationBuilder()
  7.                 .AddReomteConfig("http://127.0.0.1:5000/config", "myapp", "dev");
  9.             var config = builder.Build();
  10.             while (true)
  11.             {
  12.                 Console.WriteLine(config["Name"]);
  13.                 Thread.Sleep(1000);
  14.             }
  15.         }
  16.     }
复制代码
同时启动配置中心和客户端，打开配置中心的 Swagger 地址，修改并推送新的配置到客户端。
2.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
配置NET高级开发系统

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
蝓俟佐
9 小时前

0

粉丝关注

14

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫