前言
我正在写FastGithub这个小麻雀项目，里面主要涉及了Pipeline模式和Factory+Provider模式，这两种设计模式，让这个项目在"ip扫描"和"ip查找"两个核心功能上如鱼得水，在此分享给大家。
Pipeline
Pipeline模式也叫管道模式或流水线模式。通过预先设定好的一系列的阶段来处理输入的数据，每个阶段的输出即是下一个阶段的输入，每个阶段可以选择是否继续执行一下阶段。
上下文对象
在实现上，我们把所需的所有数据封装在上下文对象，每个阶段可以共享到同一份上下文对象。
中间件
在实现上，我们把每个阶段的处理封装为中间件，一个中间件可以访问到上下文对象和下一个阶段的处理对象，在执行时可以访问或修改上下文对象的数据。
实现详解
完整的Pipeline构建代码，详见https://github.com/xljiulang/FastGithub/tree/master/FastGithub.Core
阶段处理对象
/// <summary>
/// 表示所有中间件执行委托
/// </summary>
/// <typeparam name="TContext">中间件上下文类型</typeparam>
/// <param name="context">中间件上下文</param>
/// <returns></returns>
public delegate Task InvokeDelegate<TContext>(TContext context);
委托中间件
Func<InvokeDelegate<TContext>, InvokeDelegate<TContext>>为一个委托中间件，第一个InvokeDelegate<TContext>表示传入的下一个处理阶段，第二个InvokeDelegate<TContext>表示当前处理阶段。
/// <summary>
/// 定义中间件管道创建者的接口
/// </summary>
/// <typeparam name="TContext">中间件上下文</typeparam>
public interface IPipelineBuilder<TContext>
{
/// <summary>
/// 使用中间件
/// </summary>
/// <param name="middleware">中间件</param>
/// <returns></returns>
IPipelineBuilder<TContext> Use(Func<InvokeDelegate<TContext>, InvokeDelegate<TContext>> middleware);
/// <summary>
/// 创建所有中间件执行处理者
/// </summary>
/// <returns></returns>
InvokeDelegate<TContext> Build();
}
强类型中间件
我们可以把委托中间件，转换为如下的强类型中间件，InvokeAsync方法是本处理阶段，next参数，是委托中间件的下个阶段包装。
/// <summary>
/// 定义中间件的接口
/// </summary>
/// <typeparam name="TContext"></typeparam>
public interface IMiddleware<TContext>
{
/// <summary>
/// 执行中间件
/// </summary>
/// <param name="context">上下文</param>
/// <param name="next">下一个中间件</param>
/// <returns></returns>
Task InvokeAsync(TContext context, Func<Task> next);
}
使用详解
扫描任务分为完整扫描和历史结果扫描，使用的中间件有点差异，但都是把需要的中间件串起来就可以了。
/// <summary>
/// github扫描服务
/// </summary>
/// <param name="domainAddressFactory"></param>
/// <param name="scanResults"></param>
/// <param name="appService"></param>
/// <param name="logger"></param>
public GithubScanService(
DomainAddressFacotry domainAddressFactory,
GithubContextCollection scanResults,
IServiceProvider appService,
ILogger<GithubScanService> logger)
{
this.domainAddressFactory = domainAddressFactory;
this.scanResults = scanResults;
this.logger = logger;
this.fullScanDelegate = new PipelineBuilder<GithubContext>(appService, ctx => Task.CompletedTask)
.Use<ConcurrentMiddleware>()
.Use<StatisticsMiddleware>()
.Use<TcpScanMiddleware>()
.Use<HttpsScanMiddleware>()
.Build();
this.resultScanDelegate = new PipelineBuilder<GithubContext>(appService, ctx => Task.CompletedTask)
.Use<StatisticsMiddleware>()
.Use<HttpsScanMiddleware>()
.Build();
}
Factory+Provider
多个Provider可以使用不同手段获取到github的ip，Factory再把各Provider得到的ip进行整合，他们都是得到相同的功能：拿到github的ip，只是各个Provider才是具体干活的，而且Provider之间没有任何有关系。
IDomainAddressProvider
/// <summary>
/// 定义域名的ip提值者
/// </summary>
interface IDomainAddressProvider
{
/// <summary>
/// 创建域名与ip的关系
/// </summary>
/// <returns></returns>
Task<IEnumerable<DomainAddress>> CreateDomainAddressesAsync();
}
DomainAddressFacotry
/// <summary>
/// 域名与ip关系工厂
/// </summary>
[Service(ServiceLifetime.Singleton)]
sealed class DomainAddressFacotry
{
private readonly IEnumerable<IDomainAddressProvider> providers;
/// <summary>
/// 域名与ip关系工厂
/// </summary>
/// <param name="providers"></param>
public DomainAddressFacotry(IEnumerable<IDomainAddressProvider> providers)
{
this.providers = providers;
}
/// <summary>
/// 创建域名与ip的关系
/// </summary>
/// <returns></returns>
public async Task<IEnumerable<DomainAddress>> CreateDomainAddressesAsync()
{
var hashSet = new HashSet<DomainAddress>();
foreach (var provider in this.providers)
{
var domainAddresses = await provider.CreateDomainAddressesAsync();
foreach (var item in domainAddresses)
{
hashSet.Add(item);
}
}
return hashSet;
}
}
模式优势分析
FastGithub同时使用了上述两种模式，其工作流程很简单：使用DomainAddressFacotry创建要扫描的ip，然后使用pipeline创建得到的扫描委托进行扫描即可。想得到更多的ip，增加一个DomainAddressProvider即可，不影响到其它任何代码流程，想在扫描过程中做其它扫描逻辑，增加一个扫描中间件并安装到合适位置即可。