如何实现一套.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();
浙公网安备 33010602011771号