如何实现一套.net系统集成多个飞书应用

想象一下，你的公司是一个分布式系统，不同部门像独立服务一样拥有各自的业务逻辑、数据模型和通信方式。如何实现一个统一的集成引擎，能够无缝连接所有部门服务，背后需要拥有一套高效的技术架构。

多应用困境的技术难题

第一次接触飞书多应用开发的那个下午，会议室的白板上画满了混乱的线条。左边是HR系统，右边是项目管理，中间夹着财务审批，每个系统都要求独立的飞书应用。技术团队讨论着"OAuth2.0"、"Webhook签名验证"和"令牌刷新机制"，而我------一个技术研发人员，脑子里只有一个问题：

"我们能不能像管理一套微服务架构那样管理这些应用，同时保持技术的专业性和可扩展性？"

通过深入分析多应用集成场景，我们找到了系统性解决方案：采用统一的应用上下文管理、智能事件路由和完善的安全验证体系构建微服务架构。
graph TD A[企业多应用困境] --> B{解决方案选择} B --> C[传统方式：独立开发] B --> D[MudFeishu：统一集成] C --> C1[重复代码] C --> C2[令牌管理混乱] C --> C3[事件处理分散] D --> D1[统一配置中心] D --> D2[自动令牌管理] D --> D3[集中事件处理] C1 --> E[开发效率低] C2 --> F[维护成本高] C3 --> G[系统不稳定] D1 --> H[配置如写诗] D2 --> I[令牌自动刷新] D3 --> J[事件智能路由] E --> K[❌ 项目延期] F --> K G --> K H --> L[✅ 优雅高效] I --> L J --> L

MudFeishu如何集成多个飞书应用

认识你的"服务组件"

安装MudFeishu就像为系统架构选择专业组件：

# 核心组件 - 必须安装
dotnet add package Mud.Feishu           # 核心服务（HTTP API客户端）
dotnet add package Mud.Feishu.Abstractions # 接口定义（核心抽象层）

# 专业组件 - 按需安装
dotnet add package Mud.Feishu.WebSocket   # 实时事件订阅（WebSocket长连接）
dotnet add package Mud.Feishu.Webhook     # Webhook事件处理（HTTP回调）
dotnet add package Mud.Feishu.Redis       # 分布式缓存（Redis支持）

组件能力矩阵：

组件	HTTP API调用	实时事件订阅	Webhook处理	多应用支持	分布式缓存
Mud.Feishu	✅	❌	❌	✅	❌
Mud.Feishu.WebSocket	❌	✅	❌	❌	可选
Mud.Feishu.Webhook	❌	❌	✅	✅	可选
Mud.Feishu.Redis	❌	❌	❌	✅	✅

为每个服务配置参数

在appsettings.json中，我们为每个应用创建"服务配置"：

{
  "FeishuWebhook": {
    "GlobalRoutePrefix": "feishu",
    "AutoRegisterEndpoint": true,
    "EnableRequestLogging": true,
    "EnableExceptionHandling": true,
    "EventHandlingTimeoutMs": 30000,
    "MaxConcurrentEvents": 10,
    "Apps": {
      "app1": {
        "VerificationToken": "app1_verification_token_example_12345678",
        "EncryptKey": "app1_encrypt_key_example_32_bytes"
      },
      "app2": {
        "VerificationToken": "app2_verification_token_example_87654321",
        "EncryptKey": "app2_encrypt_key_example_32_bytes_also"
      }
    }
  }
}

表1：应用"服务配置"字段解读

字段名	技术解读	架构比喻	技术实质
AppKey	应用唯一标识	服务标识符	应用唯一标识符
VerificationToken	验证令牌	服务令牌	飞书事件验证令牌
EncryptKey	加密密钥	安全密钥	飞书事件加密密钥
GlobalRoutePrefix	全局路由前缀	服务路由前缀	Webhook路由前缀
EventHandlingTimeoutMs	事件处理超时	处理超时设置	事件处理最大时间
MaxConcurrentEvents	最大并发事件	并发处理能力	同时处理的事件数

服务组件的注册仪式（技术实现）

在Program.cs中，我们进行服务组件的注册，并配置多应用处理器：

// 服务组件注册 - Program.cs
using Mud.Feishu.Webhook.Demo;
using Mud.Feishu.Webhook.Demo.Handlers.MultiApp;
using Mud.Feishu.Webhook.Demo.Interceptors;

var builder = WebApplication.CreateBuilder(args);

// 注册演示服务
builder.Services.AddSingleton<DemoEventService>();

// 注册飞书服务端SDK（多应用模式）
// 方式1：从配置文件加载
builder.Services.AddFeishuApp(builder.Configuration, "Feishu");

// 方式2：代码配置（可选，如果需要动态添加应用）
// builder.Services.AddFeishuApp(configure =>
// {
//     config.AddDefaultApp("default", "cli_xxx", "dsk_xxx");
//     config.AddApp("hr-app", "cli_yyy", "dsk_yyy", opt =>
//     {
//         opt.TimeOut = 45;
//         opt.RetryCount = 5;
//     });
// });

// 按需注册飞书API服务
builder.Services.AddFeishuServices(services =>
{
    services
        .AddAllApis()  // 注册所有API模块
        // 或者按需注册：
        // .AddOrganizationApi()    // 组织管理API
        // .AddMessageApi()         // 消息管理API
        // .AddChatGroupApi()       // 群聊管理API
        // .AddApprovalApi()        // 审批管理API
        // .AddTaskApi()            // 任务管理API
        // .AddCardApi()            // 卡片管理API
        // .AddAttendanceApi();     // 考勤管理API
});

// 注册飞书Webhook服务（多应用模式）
builder.Services.CreateFeishuWebhookServiceBuilder(builder.Configuration, "FeishuWebhook")
    // 添加全局拦截器（所有应用共享）
    .AddInterceptor<LoggingEventInterceptor>() // 日志拦截器（内置）
    .AddInterceptor<TelemetryEventInterceptor>(sp => new TelemetryEventInterceptor("Mud.Feishu.Webhook.Demo.MultiApp")) // 遥测拦截器（内置）
    .AddInterceptor<AuditLogInterceptor>() // 审计日志拦截器（自定义）
    .AddInterceptor<PerformanceMonitoringInterceptor>() // 性能监控拦截器（自定义）

    // 为 App1 添加处理器和拦截器（组织架构相关事件）
    .AddHandler<App1DepartmentEventHandler>("app1")
    .AddHandler<App1DepartmentDeleteEventHandler>("app1")
    .AddHandler<App1DepartmentUpdateEventHandler>("app1")
    .AddInterceptor<App1SpecificInterceptor>("app1") // App1 特定的拦截器

    // 为 App2 添加处理器和拦截器（审批相关事件）
    .AddHandler<App2ApprovalPassedEventHandler>("app2")
    .AddHandler<App2ApprovalRejectedEventHandler>("app2")
    .AddHandler<App2DepartmentDeleteEventHandler>("app2") // App2 部门删除事件处理器
    .AddInterceptor<App2SpecificInterceptor>("app2") // App2 特定的拦截器

    .Build();

var app = builder.Build();

// 添加多应用信息端点
app.MapMultiAppInfo();

// 添加诊断端点
app.MapDiagnostics();

// 添加测试端点（用于捕获飞书回调数据）
app.MapTestEndpoints();

// 添加飞书Webhook限流中间件（可选，推荐在生产环境启用）
app.UseFeishuRateLimit();

// 添加飞书Webhook中间件（自动注册多应用端点）
app.UseFeishuWebhook();

app.Run();

多应用SDK的两种调用模式

MudFeishu提供两种方式调用多应用API，根据场景选择最适合的方式。

方式一：通过IFeishuAppManager调用（推荐用于临时切换）

public class MultiAppService
{
    private readonly IFeishuAppManager _feishuAppManager;

    // 获取指定应用的API实例
    var userApi = _feishuAppManager.GetFeishuApi<IFeishuV3User>("hr-app");
    var user = await userApi.GetUserAsync(userId);

    var approvalApi = _feishuAppManager.GetFeishuApi<IFeishuV4Approval>("approval-app");
    var approval = await approvalApi.CreateApprovalInstanceAsync(request);
}

方式二：通过应用上下文切换（推荐用于频繁切换的场景）

// 切换到指定应用
_feishuV3User.UseApp("hr-app");
var user = await _feishuV3User.GetUserAsync(userId);
_feishuV3User.UseDefaultApp(); // 切回默认应用

// 批量向多个应用发送消息
var apps = new[] { "default", "hr-app", "approval-app" };
foreach (var app in apps)
{
    _feishuV1Message.UseApp(app);
    await _feishuV1Message.SendMessageAsync(request);
}
_feishuV1Message.UseDefaultApp();

两种方式对比：

特性	IFeishuAppManager方式	应用上下文切换方式
适用场景	临时调用、少量切换	频繁切换、批量操作
代码简洁性	简洁，每次指定应用	需要手动切换和还原
线程安全	完全线程安全	需要注意线程隔离
性能开销	较小，每次调用独立	较小，状态切换快速
推荐指数	⭐⭐⭐⭐⭐	⭐⭐⭐⭐

多应用架构的核心设计理念

MudFeishu的多应用架构基于以下几个核心设计理念，确保系统的高可用性和可扩展性。

完全隔离机制

每个飞书应用在系统中拥有完全独立的资源：

资源类型	隔离方式	说明
HTTP客户端	每个应用独立的HttpClient实例	避免连接池复用导致的状态污染
令牌缓存	前缀隔离（appKey:tokenType:userId）	确保不同应用的令牌不冲突
令牌管理器	每个应用独立的租户/应用/用户令牌管理器	独立的令牌生命周期管理
事件处理器	按AppKey注册	每个应用可以有独立的事件处理逻辑
事件拦截器	全局+应用级两层拦截器	支持统一的跨应用拦截和应用特定拦截

// 缓存键前缀示例
// default应用： "default:tenant:token", "default:app:token", "default:user:123"
// hr-app应用：   "hr-app:tenant:token", "hr-app:app:token", "hr-app:user:456"
// approval应用： "approval:tenant:token", "approval:app:token", "approval:user:789"

智能默认应用推断

MudFeishu提供智能的默认应用推断机制，减少配置复杂度：

// 规则1：AppKey为"default"时自动设置为默认应用
var config1 = new FeishuAppConfig
{
    AppKey = "default",
    AppId = "cli_xxx",
    AppSecret = "dsk_xxx"
    // IsDefault 自动设置为 true
};

// 规则2：只配置一个应用时自动设置为默认应用
var configs = new List<FeishuAppConfig>
{
    new FeishuAppConfig { AppKey = "hr-app", AppId = "cli_xxx", AppSecret = "dsk_xxx" }
    // IsDefault 自动设置为 true
};

// 规则3：多个应用时，第一个默认为默认应用
var configs = new List<FeishuAppConfig>
{
    new FeishuAppConfig { AppKey = "app1", AppId = "cli_xxx", AppSecret = "dsk_xxx" }, // 默认
    new FeishuAppConfig { AppKey = "app2", AppId = "cli_yyy", AppSecret = "dsk_yyy" }
};

运行时动态管理

支持在运行时动态添加和移除应用：

public class DynamicAppService
{
    private readonly IFeishuAppManager _appManager;

    public DynamicAppService(IFeishuAppManager appManager)
    {
        _appManager = appManager;
    }

    public void AddNewApplication()
    {
        // 动态添加新应用
        var newConfig = new FeishuAppConfig
        {
            AppKey = "new-project-app",
            AppId = "cli_new_xxx",
            AppSecret = "dsk_new_xxx",
            TimeOut = 30,
            RetryCount = 3
        };

        _appManager.AddApp(newConfig);
    }

    public void RemoveOldApplication()
    {
        // 移除应用（注意：不能移除默认应用）
        if (_appManager.RemoveApp("old-project-app"))
        {
            Console.WriteLine("应用已成功移除");
        }
    }

    public IEnumerable<string> GetAllApplications()
    {
        // 获取所有应用
        return _appManager.GetAllApps().Select(app => app.Config.AppKey);
    }
}

安全的配置验证

MudFeishu提供完整的配置验证机制，确保配置的正确性：

try
{
    // 自动验证所有配置项
    var configs = new List<FeishuAppConfig>
    {
        new FeishuAppConfig
        {
            AppKey = "test",
            AppId = "cli_invalid",  // 将触发验证错误
            AppSecret = "short",      // 将触发验证错误
        }
    };

    // 验证时会检查：
    // 1. AppKey不能为空
    // 2. AppId格式必须以"cli_"或"app_"开头，且长度>=20
    // 3. AppSecret长度必须>=16
    // 4. TimeOut必须在1-300秒之间
    // 5. RetryCount必须在0-10次之间
    // 6. RetryDelayMs必须在100-60000毫秒之间
    // 7. TokenRefreshThreshold必须在60-3600秒之间
    // 8. BaseUrl必须是有效的URI
    // 9. 不允许重复的AppKey

    foreach (var config in configs)
    {
        config.Validate();
    }
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"配置验证失败: {ex.Message}");
}

技术实践：多场景应用

场景一：新员工入职的"多服务协同"

当一位新员工加入公司，三个系统需要协同工作：
sequenceDiagram participant A as HR系统 participant B as IT系统 participant C as 行政部门 participant M as MudFeishu集成中心 Note over A: 新员工王小明入职 A->>M: 发送"员工创建"事件 M->>B: ① 创建邮箱账号<br/>分配技术资源 M->>C: ② 准备办公设备<br/>安排工位 B->>M: 邮箱创建完成 C->>M: 工位准备就绪 M->>A: 汇总报告：王小明已就绪 Note over M: 集成中心协调完成<br/>耗时：2.3秒

// 协调多个应用处理新员工入职
public async Task OrchestrateEmployeeOnboarding(string employeeId)
{
    var hrApi = _appManager.GetFeishuApi<IFeishuV3User>("hr-app");
    var messageApi = _appManager.GetFeishuApi<IFeishuV1Message>("default");
    var approvalApi = _appManager.GetFeishuApi<IFeishuV4Approval>("approval-app");

    // 并行执行服务任务
    await Task.WhenAll(
        hrApi.GetUserAsync(employeeId),
        messageApi.SendMessageAsync(new MessageRequest
        {
            ReceiveId = "it-department",
            Content = $"新员工 {employeeId} 入职，需创建邮箱账号",
            MsgType = "text"
        }),
        approvalApi.CreateApprovalInstanceAsync(new ApprovalInstanceRequest
        {
            ApprovalCode = "WORKSTATION_SETUP",
            Userid = employeeId
            // ... 完整审批配置
        })
    );

    // 发送统一通知
    await messageApi.SendMessageAsync(new MessageRequest
    {
        ReceiveId = "hr-department",
        ReceiveIdType = ReceiveIdType.chat_id,
        Content = $"新员工 {employeeId} 入职流程完成",
        MsgType = "text"
    });
}

场景二：部门删除事件的"跨系统协调"

当公司删除一个部门时，需要多个系统协同清理数据：

// 部门删除事件处理器
public class App2DepartmentDeleteEventHandler : DepartmentDeleteEventHandler
{
    protected override async Task ProcessBusinessLogicAsync(
        EventData eventData,
        DepartmentDeleteResult? eventEntity,
        CancellationToken cancellationToken = default)
    {
        _logger.LogInformation("处理部门删除事件: {EventId}", eventData.EventId);

        // 清理该部门在App2中的相关数据
        await ProcessDepartmentDeleteAsync(eventEntity, cancellationToken);
    }

    private async Task ProcessDepartmentDeleteAsync(DepartmentDeleteResult? departmentData, CancellationToken cancellationToken)
    {
        if (!string.IsNullOrWhiteSpace(departmentData?.Object?.DepartmentId))
        {
            // TODO: 实现实际的清理逻辑
            _logger.LogInformation("清理App2部门数据: {DepartmentId}", departmentData.Object?.DepartmentId);
        }
    }
}

场景三：跨部门审批的"服务协调"

财务审批需要HR和项目部门共同确认：

// 跨部门预算审批流程
public async Task<bool> ProcessBudgetApproval(string applicantId, decimal amount)
{
    var approvalApi = _feishuAppManager.GetFeishuApi<IFeishuV4Approval>("approval-app");

    // 1. 检查HR政策
    var hrPolicy = await CheckHrPolicyAsync(applicantId, amount);
    if (!hrPolicy.Allowed) return false;

    // 2. 验证项目预算
    var budgetStatus = await CheckProjectBudgetAsync(applicantId, amount);
    if (!budgetStatus.HasEnough) return false;

    // 3. 启动审批流程
    var approval = await approvalApi.CreateApprovalInstanceAsync(
        new ApprovalInstanceRequest
        {
            ApprovalCode = "BUDGET_2024",
            Userid = applicantId
        });

    return approval.ApprovalInstance.Status == "APPROVED";
}

表2：跨部门审批的"服务协议"

审批阶段	涉及部门	沟通方式	超时处理	技术解读
政策核查	HR部门	系统调用	24小时内回复	查阅HR政策数据
预算确认	项目部门	紧急通知	4小时内回复	确认预算充足
审批流转	财务部门	内部通知	实时推进	启动审批流程
结果通知	所有部门	系统通知	立即发送	发布审批结果

企业级特性：分布式缓存和断路器

MudFeishu提供企业级的分布式缓存和断路器支持，确保系统在高并发场景下的稳定性。

分布式令牌缓存

使用Redis作为分布式令牌缓存，适用于多实例部署场景：

// 安装Redis支持包
// dotnet add package Mud.Feishu.Redis

// 在Program.cs中配置Redis缓存
builder.Services.AddFeishuRedisCache(builder.Configuration.GetSection("Redis"));

// Redis配置示例
{
  "Redis": {
    "ServerAddress": "localhost:6379",
    "Password": "",
    "EventCacheExpiration": "24:00:00",  // 事件缓存24小时
    "NonceTtl": "00:05:00",              // Nonce有效期5分钟
    "ConnectTimeout": 5000,
    "SyncTimeout": 5000,
    "Ssl": false,
    "AllowAdmin": true,
    "AbortOnConnectFail": true,
    "ConnectRetry": 3
  }
}

分布式缓存的优势：

特性	内存缓存	Redis分布式缓存
多实例共享	❌ 不支持	✅ 支持
持久化	❌ 实例重启丢失	✅ 支持持久化
高可用	❌ 单点故障	✅ 支持主从复制
扩展性	❌ 受限于单机内存	✅ 可横向扩展
适用场景	单机部署	生产环境多实例部署

断路器模式

MudFeishu内置断路器模式，保护下游服务不被过载：

{
  "FeishuWebhook": {
    "EnableCircuitBreaker": true,
    "CircuitBreaker": {
      "ExceptionsAllowedBeforeBreaking": 5,        // 允许5次异常后开启断路器
      "DurationOfBreakSeconds": 30,               // 断路器保持开启30秒
      "SuccessThresholdToReset": 3               // 3次成功后重置断路器
    }
  }
}

断路器工作原理：
stateDiagram-v2 [*] --> Closed: 系统正常 Closed --> Open: 异常次数超过阈值 Open --> HalfOpen: 等待时间结束 HalfOpen --> Closed: 成功次数达到阈值 HalfOpen --> Open: 再次发生异常 Open --> [*]: 拒绝请求 Closed --> [*]: 正常处理请求

智能重试机制

MudFeishu提供指数退避的智能重试机制：

{
  "Feishu": [
    {
      "AppKey": "default",
      "AppId": "cli_xxx",
      "AppSecret": "dsk_xxx",
      "RetryCount": 3,              // 最多重试3次
      "RetryDelayMs": 1000,         // 初始延迟1秒
      "TimeOut": 30                // 单次请求超时30秒
    }
  ]
}

重试策略：

重试次数	延迟时间	计算方式
第1次重试	1000ms	基础延迟
第2次重试	2000ms	基础延迟 × 2^1
第3次重试	4000ms	基础延迟 × 2^2

限流保护

防止系统被恶意或异常流量冲击：

{
  "FeishuWebhook": {
    "RateLimit": {
      "EnableRateLimit": true,
      "WindowSizeSeconds": 60,          // 时间窗口：60秒
      "MaxRequestsPerWindow": 100,       // 最大请求数：100
      "TooManyRequestsStatusCode": 429   // 超限返回HTTP 429
    }
  }
}

网络波动：服务的"备用路由"

graph LR A[发送服务请求] --> B{网络通道选择} B -->|主通道| C[HTTPS直连] B -->|备用通道| D[WebSocket长连接] B -->|紧急通道| E[消息队列缓存] C --> F{是否成功?} D --> F E --> F F -->|✅ 成功| G[送达确认] F -->|❌ 失败| H[重试决策树] H --> I{失败类型分析} I -->|临时波动| J[5秒后重试] I -->|权限问题| K[刷新令牌] I -->|服务异常| L[切换备用服务器] J --> M[最多重试3次] K --> M L --> M M --> N{最终结果} N -->|成功| G N -->|失败| O[人工介入] O --> P[服务降级处理] P --> Q[问题记录与改进] style A fill:#e1f5fe style G fill:#c8e6c9 style O fill:#ffccbc

从1到100：规模化服务架构

小型企业（1-5个应用）的"中心服务模式"

graph TB subgraph "小型企业服务架构" A[企业总部] --> B[MudFeishu集成中心] B --> C[👥 HR服务] B --> D[💰 财务服务] B --> E[💻 IT服务] C --> F[飞书HR应用] D --> G[飞书财务应用] E --> H[飞书IT应用] style B fill:#bbdefb style C fill:#c8e6c9 style D fill:#fff9c4 style E fill:#ffccbc end

特点：直接连接，配置简单，适合初创企业或部门较少的中小企业。

中型企业（5-20个应用）的"服务集群网络"

graph TB subgraph "中型企业服务架构" A[企业总部] --> B[服务总中心<br/>MudFeishu核心] B --> C[华东服务集群] B --> D[华南服务集群] B --> E[华北服务集群] C --> C1[👥 HR服务] C --> C2[💰 财务服务] D --> D1[💻 IT服务] D --> D2[📊 数据服务] E --> E1[🎯 项目服务] E --> E2[📦 物流服务] C1 --> F1[飞书HR应用] C2 --> F2[飞书财务应用] D1 --> F3[飞书IT应用] D2 --> F4[飞书数据应用] E1 --> F5[飞书项目应用] E2 --> F6[飞书物流应用] style B fill:#0d47a1 style C fill:#bbdefb style D fill:#bbdefb style E fill:#bbdefb end

特点：按地域或业务线分区管理，提高响应速度，适合多地域运营的中型企业。

大型集团（20+个应用）的"服务总线体系"

MudFeishu支持大型企业的规模化部署，通过模块化设计和分布式架构，轻松管理20+个应用：

// 大型集团服务架构配置示例
public void ConfigureLargeEnterprise(IServiceCollection services, IConfiguration config)
{
    // 1. 核心服务配置
    services.CreateFeishuWebhookServiceBuilder(config, "FeishuWebhook")
        // 全局拦截器
        .AddInterceptor<LoggingEventInterceptor>()
        .AddInterceptor<TelemetryEventInterceptor>()

        // 业务线1：HR相关应用
        .AddHandler<HrEmployeeEventHandler>("hr-system")
        .AddHandler<HrDepartmentEventHandler>("hr-system")

        // 业务线2：财务相关应用
        .AddHandler<FinanceApprovalHandler>("finance-system")
        .AddHandler<FinanceReportHandler>("finance-system")

        // 业务线3：IT相关应用
        .AddHandler<ItAssetHandler>("it-system")
        .AddHandler<ItIncidentHandler>("it-system")

        .Build();

    // 2. 分布式缓存配置
    services.AddFeishuRedisCache(config.GetSection("Redis"));

    // 3. 健康检查配置
    services.AddHealthChecks()
        .AddCheck<FeishuWebhookHealthCheck>("feishu-webhook")
        .AddRedis(config.GetConnectionString("Redis"), name: "redis");
}

高可用性架构：服务网络的"冗余备份"

MudFeishu支持高可用性部署，确保在各种情况下都能保持服务稳定：

// 高可用性配置示例
public void ConfigureHighAvailability(IServiceCollection services, IConfiguration config)
{
    // 1. 多实例部署支持
    services.AddSingleton<IFeishuEventDeduplicator, RedisFeishuEventDistributedDeduplicator>();

    // 2. 故障转移机制
    services.AddSingleton<IFailedEventStore, RedisFailedEventStore>();

    // 3. 负载均衡和断路器
    services.Configure<FeishuWebhookOptions>(options =>
    {
        options.EnableCircuitBreaker = true;
        options.CircuitBreakerOptions = new CircuitBreakerOptions
        {
            FailureThreshold = 0.5,
            SamplingDuration = TimeSpan.FromMinutes(1),
            DurationOfBreak = TimeSpan.FromMinutes(2)
        };
    });
}

快速开始

1. 安装包

dotnet add package Mud.Feishu
dotnet add package Mud.Feishu.Webhook
dotnet add package Mud.Feishu.Redis  # 可选

2. 配置文件

{
  "Feishu": [
    {
      "AppKey": "default",
      "AppId": "cli_xxx",
      "AppSecret": "dsk_xxx"
    },
    {
      "AppKey": "hr-app",
      "AppId": "cli_yyy",
      "AppSecret": "dsk_yyy"
    }
  ],
  "FeishuWebhook": {
    "GlobalRoutePrefix": "feishu",
    "Apps": {
      "default": {
        "VerificationToken": "your_token",
        "EncryptKey": "your_32byte_key"
      }
    }
  }
}

3. 服务注册

// 注册飞书SDK
builder.Services.AddFeishuApp(builder.Configuration, "Feishu");
builder.Services.AddFeishuServices(services =>
    services.AddAllApis());

// 注册Webhook服务
builder.Services.CreateFeishuWebhookServiceBuilder(builder.Configuration, "FeishuWebhook")
    .AddHandler<MyEventHandler>("default")
    .Build();

// 使用中间件
app.UseFeishuWebhook();

参考资源

• 📖 飞书官方文档
• 💻 MudFeishu GitHub 仓库
• 💻 MudFeishu Gitee 仓库