ABP框架 - 功能管理：从概念到实战的完整指南

dotnet add package Volo.Abp.FeatureManagement.Domain
dotnet add package Volo.Abp.FeatureManagement.Web # 若需要管理UI

using Volo.Abp.FeatureManagement;
 
[DependsOn(
    typeof(AbpFeatureManagementDomainModule), // 核心模块
    typeof(AbpFeatureManagementWebModule)   // Web模块（可选）
)]
public class MyAppModule : AbpModule
{
    // ...
}

using Volo.Abp.FeatureManagement.Definitions;
using Volo.Abp.Localization;
 
// 推荐：用常量定义功能名称，避免硬编码
public static class MyAppFeatures
{
    public const string BlogGroup = "MyApp.Blog";
    
    public const string BlogCreation = "MyApp.Blog.Creation";
    public const string MaxPosts = "MyApp.Blog.MaxPosts";
    public const string AllowedThemes = "MyApp.Blog.AllowedThemes";
}
 
public class MyAppFeatureDefinitionProvider : FeatureDefinitionProvider
{
    public override void Define(IFeatureDefinitionContext context)
    {
        // 1. 添加功能组（可选，用于管理UI分组）
        var blogGroup = context.AddGroup(MyAppFeatures.BlogGroup);
 
        // 2. 添加布尔型功能：允许创建博客
        blogGroup.AddFeature(
            name: MyAppFeatures.BlogCreation,
            displayName: L("Features.Blog.Creation.DisplayName"), // 本地化显示名
            description: L("Features.Blog.Creation.Description"), // 本地化描述
            type: FeatureType.Boolean,
            defaultValue: "true" // 全局默认启用
        );
 
        // 3. 添加值类型功能：最大文章数（需自行解析为int）
        blogGroup.AddFeature(
            name: MyAppFeatures.MaxPosts,
            displayName: L("Features.Blog.MaxPosts.DisplayName"),
            description: L("Features.Blog.MaxPosts.Description"),
            type: FeatureType.Value,
            defaultValue: "50" // 全局默认50篇
        );
 
        // 4. 添加数组类型功能：允许的主题列表
        blogGroup.AddFeature(
            name: MyAppFeatures.AllowedThemes,
            displayName: L("Features.Blog.AllowedThemes.DisplayName"),
            description: L("Features.Blog.AllowedThemes.Description"),
            type: FeatureType.Array,
            defaultValue: "light,dark" // 全局默认支持light和dark主题
        );
    }
 
    // 本地化辅助方法：从MyAppResource中获取字符串
    private static LocalizableString L(string name)
    {
        return LocalizableString.Create<MyAppResource>(name);
    }
}

blogGroup.AddFeature(
    name: MyAppFeatures.CustomThemes,
    type: FeatureType.Boolean,
    defaultValue: "false"
).AddDependency(MyAppFeatures.BlogCreation); // 依赖BlogCreation功能

public class BlogAppService : ApplicationService
{
    private readonly IFeatureChecker _featureChecker;
 
    public BlogAppService(IFeatureChecker featureChecker)
    {
        _featureChecker = featureChecker;
    }
 
    public async Task CreateBlogAsync(CreateBlogDto input)
    {
        // 检查BlogCreation功能是否启用
        if (!await _featureChecker.IsEnabledAsync(MyAppFeatures.BlogCreation))
        {
            throw new FeatureException("不允许创建博客，请联系管理员！");
        }
 
        // 业务逻辑...
    }
}

public async Task<int> GetMaxPostsAsync()
{
    // 获取MaxPosts的值（自动处理范围优先级）
    var maxPostsValue = await _featureChecker.GetValueAsync(MyAppFeatures.MaxPosts);
    return int.Parse(maxPostsValue); // 解析为int
}
 
public async Task<List<string>> GetAllowedThemesAsync()
{
    // 获取Array类型的值（逗号分隔）
    var themesValue = await _featureChecker.GetValueAsync(MyAppFeatures.AllowedThemes);
    return themesValue.Split(',').ToList();
}

[ApiController]
[Route("api/blogs")]
public class BlogController : AbpControllerBase
{
    // 仅当BlogCreation启用时，才能访问该接口
    [HttpPost]
    [FeatureCheck(MyAppFeatures.BlogCreation)]
    public async Task<IActionResult> CreateAsync(CreateBlogDto input)
    {
        // 业务逻辑...
    }
}

@page "/blogs"
@inject IFeatureChecker FeatureChecker
 
<h1>我的博客</h1>
 
@if (await FeatureChecker.IsEnabledAsync(MyAppFeatures.CustomThemes))
{
    <div class="custom-themes">
        <label>选择主题：</label>
        <select @bind="SelectedTheme">
            @foreach (var theme in AllowedThemes)
            {
                <option value="@theme">@theme</option>
            }
        </select>
    </div>
}

using Volo.Abp.FeatureManagement.Validation;
 
public class CreateBlogPostDto
{
    [Required]
    public string Title { get; set; }
 
    // 验证内容长度不超过MaxPosts功能值
    [FeatureValueRange(MyAppFeatures.MaxContentLength)]
    public string Content { get; set; }
}

public class TenantFeatureAppService : ApplicationService
{
    private readonly IFeatureManager _featureManager;
    private readonly ICurrentTenant _currentTenant;
 
    public TenantFeatureAppService(IFeatureManager featureManager, ICurrentTenant currentTenant)
    {
        _featureManager = featureManager;
        _currentTenant = currentTenant;
    }
 
    public async Task UpdateMaxPostsAsync(int maxPosts)
    {
        await _featureManager.SetForTenantAsync(
            tenantId: _currentTenant.Id.Value,
            name: MyAppFeatures.MaxPosts,
            value: maxPosts.ToString()
        );
    }
}

// 在MyAppWebModule的ConfigureMenuAsync方法中添加菜单
public override async Task ConfigureMenuAsync(MenuConfigurationContext context)
{
    var adminMenu = context.Menu.GetAdministration();
    adminMenu.AddItem(new ApplicationMenuItem(
        "FeatureManagement",
        "功能管理",
        url: "/FeatureManagement",
        icon: "fa fa-cog"
    ));
}

// 从配置文件获取功能值的提供者
public class ConfigFeatureValueProvider : FeatureValueProvider
{
    public override string Name => "Config"; // 提供者名称
    private readonly IConfiguration _configuration;
 
    public ConfigFeatureValueProvider(
        IConfiguration configuration,
        FeatureManagementOptions options) 
        : base(options)
    {
        _configuration = configuration;
    }
 
    public override Task<string> GetOrNullAsync(FeatureDefinition feature)
    {
        // 从配置文件读取：Feature:MyApp.Blog.MaxPosts
        var value = _configuration.GetValue<string>($"Feature:{feature.Name}");
        return Task.FromResult(value);
    }
}

public override void ConfigureServices(ServiceConfigurationContext context)
{
    Configure<FeatureManagementOptions>(options =>
    {
        // 添加自定义提供者（优先级高于默认提供者）
        options.ValueProviders.Insert(0, typeof(ConfigFeatureValueProvider));
    });
}

public class FeatureCacheInvalidator
{
    private readonly IDistributedCache<FeatureCacheItem> _featureCache;
 
    public FeatureCacheInvalidator(IDistributedCache<FeatureCacheItem> featureCache)
    {
        _featureCache = featureCache;
    }
 
    public async Task InvalidateAsync(string featureName)
    {
        // 失效指定功能的缓存（键格式：Feature:{featureName}:{tenantId}:{userId}）
        var cacheKey = FeatureCacheItem.CalculateCacheKey(featureName, CurrentTenant.Id, CurrentUser.Id);
        await _featureCache.RemoveAsync(cacheKey);
    }
}

public static class BlogFeatures
{
    public const string GroupName = "Blog";
    
    public const string BlogCreation = "Blog.Creation";
    public const string MaxPosts = "Blog.MaxPosts";
    public const string CustomThemes = "Blog.CustomThemes";
}
 
public class BlogFeatureDefinitionProvider : FeatureDefinitionProvider
{
    public override void Define(IFeatureDefinitionContext context)
    {
        var group = context.AddGroup(BlogFeatures.GroupName);
 
        group.AddFeature(
            BlogFeatures.BlogCreation,
            L("BlogCreation.DisplayName"),
            L("BlogCreation.Description"),
            FeatureType.Boolean,
            "true"
        );
 
        group.AddFeature(
            BlogFeatures.MaxPosts,
            L("MaxPosts.DisplayName"),
            L("MaxPosts.Description"),
            new PositiveIntegerFeatureType(), // 自定义正整数类型
            "50"
        );
 
        group.AddFeature(
            BlogFeatures.CustomThemes,
            L("CustomThemes.DisplayName"),
            L("CustomThemes.Description"),
            FeatureType.Boolean,
            "false"
        ).AddDependency(BlogFeatures.BlogCreation); // 依赖BlogCreation
    }
}

public async Task CreatePostAsync(CreatePostDto input)
{
    // 检查BlogCreation是否启用
    if (!await _featureChecker.IsEnabledAsync(BlogFeatures.BlogCreation))
    {
        throw new FeatureException("不允许创建文章！");
    }
 
    // 获取当前租户的MaxPosts值
    var maxPosts = await _featureChecker.GetValueAsync<int>(BlogFeatures.MaxPosts);
    var currentCount = await _postRepository.GetCountAsync(CurrentTenant.Id);
 
    if (currentCount >= maxPosts)
    {
        throw new FeatureException($"已达到最大文章数限制（{maxPosts}篇）！");
    }
 
    // 创建文章...
}