ABP框架概念

最新推荐文章于 2024-05-24 13:39:47 发布

是刘彦宏吖

最新推荐文章于 2024-05-24 13:39:47 发布

阅读量2.5k

点赞数 1

分类专栏： ABP框架应用文章标签：数据库

本文链接：https://blog.csdn.net/kalvin_y_liu/article/details/120306556

版权

ABP框架应用专栏收录该内容

17 篇文章 9 订阅

订阅专栏

二、领域层

10，实体

11，值对象

12，仓储

13，领域服务

14，规格模式

15，工作单元

16，事件总线

17，数据过滤器

三、应用层

18，应用服务

19，数据传输对象

20，验证数据传输对象

21，授权

22，功能管理

23，审计日志

四、分布式服务层

24，ASP.NET Web API Controllers

25，动态Webapi层

26，OData整合

27，Swagger UI 整合
10，实体

实体具有Id并存储在数据库中， 实体通常映射到关系数据库的表。

1，审计接口

①当Entity被插入到实现该接口的数据库中时，ASP.NET Boilerplate会自动将CreationTime设置为当前时间。

public interface IHasCreationTime
{
    DateTime CreationTime { get; set; }
}

②ASP.NET Boilerplate在保存新实体时自动将CreatorUserId设置为当前用户的id

public interface ICreationAudited : IHasCreationTime
{
    long? CreatorUserId { get; set; }
}

③编辑时间，编辑人员

public interface IHasModificationTime
{
    DateTime? LastModificationTime { get; set; }
}

public interface IModificationAudited : IHasModificationTime
{
    long? LastModifierUserId { get; set; }
}

④如果要实现所有审计属性，可以直接实现IAudited接口：

public interface IAudited : ICreationAudited, IModificationAudited
{

}

⑤可以直接继承AuditedEntity审计类

注意：ASP.NET Boilerplate从ABP Session获取当前用户的Id。

⑥软删除

public interface ISoftDelete
{
    bool IsDeleted { get; set; }
}
public interface IDeletionAudited : ISoftDelete
{
    long? DeleterUserId { get; set; }

    DateTime? DeletionTime { get; set; }
}

⑦所有审计接口

public interface IFullAudited : IAudited, IDeletionAudited
{

}

⑧直接使用所有审计类FullAuditedEntity

2，继承IExtendableObject接口存储json字段

public class Person : Entity, IExtendableObject
{
    public string Name { get; set; }

    public string ExtensionData { get; set; }

    public Person(string name)
    {
        Name = name;
    }
}
var person = new Person("John");
//存入数据库中的值：{"CustomData":{"Value1":42,"Value2":"forty-two"},"RandomValue":178}
person.SetData("RandomValue", RandomHelper.GetRandom(1, 1000)); 
person.SetData("CustomData", new MyCustomObject { Value1 = 42, Value2 = "forty-two" });
var randomValue = person.GetData<int>("RandomValue");
var customData = person.GetData<MyCustomObject>("CustomData");

十一、值对象

与实体相反，实体拥有身份标识（id），而值对象没有。例如地址（这是一个经典的Value Object）类，如果两个地址有相同的国家/地区，城市，街道号等等，它们被认为是相同的地址。

public class Address : ValueObject<Address>
{
    public Guid CityId { get; private set; } //A reference to a City entity.

    public string Street { get; private set; }

    public int Number { get; private set; }

    public Address(Guid cityId, string street, int number)
    {
        CityId = cityId;
        Street = street;
        Number = number;
    }
}

值对象基类覆盖了相等运算符（和其他相关的运算符和方法）来比较两个值对象

var address1 = new Address(new Guid("21C67A65-ED5A-4512-AA29-66308FAAB5AF"), "Baris Manco Street", 42);
var address2 = new Address(new Guid("21C67A65-ED5A-4512-AA29-66308FAAB5AF"), "Baris Manco Street", 42);

Assert.Equal(address1, address2);
Assert.Equal(address1.GetHashCode(), address2.GetHashCode());
Assert.True(address1 == address2);
Assert.False(address1 != address2);

十二、仓储

是领域层与数据访问层的中介。每个实体（或聚合根）对应一个仓储
在领域层中定义仓储接口，在基础设施层实现

1，自定义仓储接口

public interface IPersonRepository : IRepository<Person>
{
}
public interface IPersonRepository : IRepository<Person, long>
{
}

2，基类仓储接口方法

①获取单个实体

TEntity Get(TPrimaryKey id);
Task<TEntity> GetAsync(TPrimaryKey id);
TEntity Single(Expression<Func<TEntity, bool>> predicate);
Task<TEntity> SingleAsync(Expression<Func<TEntity, bool>> predicate);
TEntity FirstOrDefault(TPrimaryKey id);
Task<TEntity> FirstOrDefaultAsync(TPrimaryKey id);
TEntity FirstOrDefault(Expression<Func<TEntity, bool>> predicate);
Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate);
TEntity Load(TPrimaryKey id);//不会从数据库中检索实体，而是延迟加载。

（它在NHibernate中实现。如果ORM提供程序未实现，Load方法与Get方法完全相同）
Get方法用于获取具有给定主键（Id）的实体。如果数据库中没有给定Id的实体，它将抛出异常。 Single方法与Get类似，但需要一个表达式而不是Id。所以，您可以编写一个lambda表达式来获取一个实体。示例用法：

var person = _personRepository.Get(42);
var person = _personRepository.Single(p => p.Name == "John");
//请注意，如果没有给定条件的实体或有多个实体，Single方法将抛出异常。

②获取实体列表

List<TEntity> GetAllList();
Task<List<TEntity>> GetAllListAsync();
List<TEntity> GetAllList(Expression<Func<TEntity, bool>> predicate);
Task<List<TEntity>> GetAllListAsync(Expression<Func<TEntity, bool>> predicate);
IQueryable<TEntity> GetAll();

GetAllList用于从数据库检索所有实体。过载可用于过滤实体。例子：

var allPeople = _personRepository.GetAllList();
var somePeople = _personRepository.GetAllList(person => person.IsActive && person.Age > 42);
GetAll返回IQueryable <T>。

所以，你可以添加Linq方法。例子：

//Example 1
var query = from person in _personRepository.GetAll()
            where person.IsActive
            orderby person.Name
            select person;
var people = query.ToList();

//Example 2:
List<Person> personList2 = _personRepository.GetAll().Where(p => p.Name.Contains("H")).OrderBy(p => p.Name).Skip(40).Take(20).ToList();

③Insert

TEntity Insert(TEntity entity);
Task<TEntity> InsertAsync(TEntity entity);
TPrimaryKey InsertAndGetId(TEntity entity);//方法返回新插入实体的ID
Task<TPrimaryKey> InsertAndGetIdAsync(TEntity entity);
TEntity InsertOrUpdate(TEntity entity);//通过检查其Id值来插入或更新给定实体
Task<TEntity> InsertOrUpdateAsync(TEntity entity);
TPrimaryKey InsertOrUpdateAndGetId(TEntity entity);//在插入或更新后返回实体的ID
Task<TPrimaryKey> InsertOrUpdateAndGetIdAsync(TEntity entity);

④Update

TEntity Update(TEntity entity);
Task<TEntity> UpdateAsync(TEntity entity);

大多数情况下，您不需要显式调用Update方法，因为在工作单元完成后，工作单元会自动保存所有更改

⑤Delete

void Delete(TEntity entity);
Task DeleteAsync(TEntity entity);
void Delete(TPrimaryKey id);
Task DeleteAsync(TPrimaryKey id);
void Delete(Expression<Func<TEntity, bool>> predicate);
Task DeleteAsync(Expression<Func<TEntity, bool>> predicate);

⑥ASP.NET Boilerplate支持异步编程模型。所以，存储库方法有Async版本。这里，使用异步模型的示例应用程序服务方法：

public class PersonAppService : AbpWpfDemoAppServiceBase, IPersonAppService
{
    private readonly IRepository<Person> _personRepository;

    public PersonAppService(IRepository<Person> personRepository)
    {
        _personRepository = personRepository;
    }

    public async Task<GetPeopleOutput> GetAllPeople()
    {
        var people = await _personRepository.GetAllListAsync();

        return new GetPeopleOutput
        {
            People = Mapper.Map<List<PersonDto>>(people)
        };
    }
}

自定义存储库方法不应包含业务逻辑或应用程序逻辑。它应该只是执行与数据有关的或orm特定的任务。

十三、领域服务

领域服务（或DDD中的服务）用于执行领域操作和业务规则。Eric Evans描述了一个好的服务应该具备下面三个特征：

和领域概念相关的操作不是一个实体或者值对象的本质部分。
该接口是在领域模型的其他元素来定义的。
操作是无状态的。

1，例子（假如我们有一个任务系统，并且将任务分配给一个人时，我们有业务规则）：

我们在这里有两个业务规则：

①任务应处于活动状态，以将其分配给新的人员。
②一个人最多可以有3个活动任务。

public interface ITaskManager : IDomainService
{
    void AssignTaskToPerson(Task task, Person person);//将任务分配给人
}
public class TaskManager : DomainService, ITaskManager
{
    public const int MaxActiveTaskCountForAPerson = 3;

    private readonly ITaskRepository _taskRepository;

    public TaskManager(ITaskRepository taskRepository)
    {
        _taskRepository = taskRepository;
    }

    public void AssignTaskToPerson(Task task, Person person)
    {
        if (task.AssignedPersonId == person.Id)
        {
            return;
        }

        if (task.State != TaskState.Active)
        {
　　　　　　　//认为这个一个应用程序错误
            throw new ApplicationException("Can not assign a task to a person when task is not active!");
        }

        if (HasPersonMaximumAssignedTask(person))
        {
　　　　　　　//向用户展示错误
            throw new UserFriendlyException(L("MaxPersonTaskLimitMessage", person.Name));
        }

        task.AssignedPersonId = person.Id;
    }

    private bool HasPersonMaximumAssignedTask(Person person)
    {
        var assignedTaskCount = _taskRepository.Count(t => t.State == TaskState.Active && t.AssignedPersonId == person.Id);
        return assignedTaskCount >= MaxActiveTaskCountForAPerson;
    }
}
public class TaskAppService : ApplicationService, ITaskAppService
{
    private readonly IRepository<Task, long> _taskRepository;
    private readonly IRepository<Person> _personRepository;
    private readonly ITaskManager _taskManager;

    public TaskAppService(IRepository<Task, long> taskRepository, IRepository<Person> personRepository, ITaskManager taskManager)
    {
        _taskRepository = taskRepository;
        _personRepository = personRepository;
        _taskManager = taskManager;
    }

    public void AssignTaskToPerson(AssignTaskToPersonInput input)
    {
        var task = _taskRepository.Get(input.TaskId);
        var person = _personRepository.Get(input.PersonId);

        _taskManager.AssignTaskToPerson(task, person);
    }
}

2，强制使用领域服务

将任务实体设计成这样：

public class Task : Entity<long>
{
    public virtual int? AssignedPersonId { get; protected set; }

    //...other members and codes of Task entity

    public void AssignToPerson(Person person, ITaskPolicy taskPolicy)
    {
        taskPolicy.CheckIfCanAssignTaskToPerson(this, person);
        AssignedPersonId = person.Id;
    }
}

我们将AssignedPersonId的setter更改为protected。所以，这个Task实体类不能被修改。添加了一个AssignToPerson方法，该方法接受人员和任务策略。 CheckIfCanAssignTaskToPerson方法检查它是否是一个有效的赋值，如果没有，则抛出正确的异常（这里的实现不重要）。那么应用服务方式就是这样的：

public void AssignTaskToPerson(AssignTaskToPersonInput input)
{
    var task = _taskRepository.Get(input.TaskId);
    var person = _personRepository.Get(input.PersonId);

    task.AssignToPerson(person, _taskPolicy);
}

十四、规格模式

规格模式是一种特定的软件设计模式。通过使用布尔逻辑将业务规则链接在一起可以重组业务规则。在实际中，它主要用于为实体或其他业务对象定义可重用的过滤器

Abp定义了规范接口，和实现。使用时只需要继承Specification

public interface ISpecification<T>
{
    bool IsSatisfiedBy(T obj);

    Expression<Func<T, bool>> ToExpression();
}

//拥有100,000美元余额的客户被认为是PREMIUM客户

public class PremiumCustomerSpecification : Specification<Customer>
{
    public override Expression<Func<Customer, bool>> ToExpression()
    {
        return (customer) => (customer.Balance >= 100000);
    }
}

//参数规范示例。

public class CustomerRegistrationYearSpecification : Specification<Customer>
{
    public int Year { get; }

    public CustomerRegistrationYearSpecification(int year)
    {
        Year = year;
    }

    public override Expression<Func<Customer, bool>> ToExpression()
    {
        return (customer) => (customer.CreationYear == Year);
    }
}
public class CustomerManager
{
    private readonly IRepository<Customer> _customerRepository;

    public CustomerManager(IRepository<Customer> customerRepository)
    {
        _customerRepository = customerRepository;
    }

    public int GetCustomerCount(ISpecification<Customer> spec)
    {
        return _customerRepository.Count(spec.ToExpression());
    }
}
count = customerManager.GetCustomerCount(new PremiumCustomerSpecification());
count = customerManager.GetCustomerCount(new CustomerRegistrationYearSpecification(2017));
var count = customerManager.GetCustomerCount(new PremiumCustomerSpecification().And(new CustomerRegistrationYearSpecification(2017)));

我们甚至可以从现有规范中创建一个新的规范类：

public class NewPremiumCustomersSpecification : AndSpecification<Customer>
{
    public NewPremiumCustomersSpecification() 
        : base(new PremiumCustomerSpecification(), new CustomerRegistrationYearSpecification(2017))
    {
    }
}
AndSpecification类是Specification类的一个子类，只有当两个规范都满足时才能满足。使用如下

var count = customerManager.GetCustomerCount(new NewPremiumCustomersSpecification());

一般不需要使用规范类，可直接使用lambda表达式

var count = _customerRepository.Count(c => c.Balance > 100000 && c.CreationYear == 2017);

十五、工作单元

如果工作方法单元调用另一个工作单元方法，则使用相同的连接和事务。
第一个进入方法管理连接和事务，其他的使用它。

应用服务方法默认是工作单元。
方法开始启动事务，方法结束提交事务。
如果发生异常则回滚。
这样应用服务方法中的所有数据库操作都将变为原子（工作单元）

1，显示使用工作单元

①在方法上引用[UnitOfWork]特性。如果是应用服务方法，则不需要应用此特性

②使用IUnitOfWorkManager

public class MyService
{
    private readonly IUnitOfWorkManager _unitOfWorkManager;
    private readonly IPersonRepository _personRepository;
    private readonly IStatisticsRepository _statisticsRepository;

    public MyService(IUnitOfWorkManager unitOfWorkManager, IPersonRepository personRepository, IStatisticsRepository statisticsRepository)
    {
        _unitOfWorkManager = unitOfWorkManager;
        _personRepository = personRepository;
        _statisticsRepository = statisticsRepository;
    }

    public void CreatePerson(CreatePersonInput input)
    {
        var person = new Person { Name = input.Name, EmailAddress = input.EmailAddress };

        using (var unitOfWork = _unitOfWorkManager.Begin())
        {
            _personRepository.Insert(person);
            _statisticsRepository.IncrementPeopleCount();

            unitOfWork.Complete();
        }
    }
}

2，禁用工作单元

[UnitOfWork(IsDisabled = true)]
public virtual void RemoveFriendship(RemoveFriendshipInput input)
{
    _friendshipRepository.Delete(input.Id);
}

3，禁用事务功能

[UnitOfWork(isTransactional: false)]
public GetTasksOutput GetTasks(GetTasksInput input)
{
    var tasks = _taskRepository.GetAllWithPeople(input.AssignedPersonId, input.State);
    return new GetTasksOutput
            {
                Tasks = Mapper.Map<List<TaskDto>>(tasks)
            };
}

4，自动保存更改
如果一个方法是工作单元，ASP.NET Boilerplate会自动在方法结束时保存所有更改。假设我们需要更新一个人的名字的方法：

[UnitOfWork]
public void UpdateName(UpdateNameInput input)
{
    var person = _personRepository.Get(input.PersonId);
    person.Name = input.NewName;
}

5，更改工作单元配置

①通常在PreInitialize方法中完成

public class SimpleTaskSystemCoreModule : AbpModule
{
    public override void PreInitialize()
    {
        Configuration.UnitOfWork.IsolationLevel = IsolationLevel.ReadCommitted;
        Configuration.UnitOfWork.Timeout = TimeSpan.FromMinutes(30);
    }

    //...other module methods
}

6，如果访问工作单元

①如果您的类派生自某些特定的基类（ApplicationService，DomainService，AbpController，AbpApiController …等），则可以直接使用CurrentUnitOfWork属性。
②您可以将IUnitOfWorkManager注入任何类并使用IUnitOfWorkManager.Current属性。

6，活动

工作单位已完成，失败和处理事件。您可以注册这些事件并执行所需的操作。例如，您可能希望在当前工作单元成功完成时运行一些代码。例：

public void CreateTask(CreateTaskInput input)
{
    var task = new Task { Description = input.Description };

    if (input.AssignedPersonId.HasValue)
    {
        task.AssignedPersonId = input.AssignedPersonId.Value;
        _unitOfWorkManager.Current.Completed += (sender, args) => { /* TODO: Send email to assigned person */ };
    }

    _taskRepository.Insert(task);
}

十六、事件总线

1，两种方式使用事件总线

①依赖注入IEventBus（属性注入比构造函数注入更适合于注入事件总线）

public class TaskAppService : ApplicationService
{
    public IEventBus EventBus { get; set; }

    public TaskAppService()
    {
        EventBus = NullEventBus.Instance;
        //NullEventBus实现空对象模式。 当你调用它的方法时，它什么都不做
    }
}

②获取默认实例（不建议直接使用EventBus.Default，因为它使得单元测试变得更加困难。）

如果不能注入，可以直接使用EventBus.Default

EventBus.Default.Trigger(…); //trigger an event
2，定义事件（ EventData类定义EventSource（哪个对象触发事件）和EventTime（触发时）属性）

在触发事件之前，应首先定义事件。事件由派生自EventData的类表示。假设我们要在任务完成时触发事件：

public class TaskCompletedEventData : EventData
{
    public int TaskId { get; set; }
}

3，预定义事件

①AbpHandledExceptionData：任何异常时触发此事件

②实体变更
还有用于实体更改的通用事件数据类：

EntityCreatingEventData <TEntity>，EntityCreatedEventData <TEntity>，EntityUpdatingEventData <TEntity>，EntityUpdatedEventData <TEntity>，EntityDeletingEventData <TEntity>和EntityDeletedEventData <TEntity>。 另外还有EntityChangingEventData <TEntity>和EntityChangedEventData <TEntity>。 可以插入，更新或删除更改。

“ing”：保存之前

“ed”：保存之后

4，触发事件

public class TaskAppService : ApplicationService
{
    public IEventBus EventBus { get; set; }

    public TaskAppService()
    {
        EventBus = NullEventBus.Instance;
    }

    public void CompleteTask(CompleteTaskInput input)
    {
        //TODO: complete the task on database...
        EventBus.Trigger(new TaskCompletedEventData {TaskId = 42});
    }
}

EventBus.Trigger(new TaskCompletedEventData { TaskId = 42 }); //明确地声明泛型参数
EventBus.Trigger(this, new TaskCompletedEventData { TaskId = 42 }); //将“事件源”设置为“this”
EventBus.Trigger(typeof(TaskCompletedEventData), this, new TaskCompletedEventData { TaskId = 42 }); //调用非泛型版本（第一个参数是事件类的类型）
public class ActivityWriter : IEventHandler, ITransientDependency
{
public void HandleEvent(TaskCompletedEventData eventData)
{
WriteActivity("A task is completed by id = " + eventData.TaskId);
}
}
5，处理多个事件

public class ActivityWriter : 
    IEventHandler<TaskCompletedEventData>, 
    IEventHandler<TaskCreatedEventData>, 
    ITransientDependency
{
    public void HandleEvent(TaskCompletedEventData eventData)
    {
        //TODO: handle the event...
    }

    public void HandleEvent(TaskCreatedEventData eventData)
    {
        //TODO: handle the event...
    }
}

十七、数据过滤器

1，ISoftDelete软删除接口

public class Person : Entity, ISoftDelete
{
public virtual string Name { get; set; }

public virtual bool IsDeleted { get; set; }

}
使用IRepository.Delete方法时将IsDeleted属性设置为true。_personRepository.GetAllList()不会查询出软删除的数据

注：如果您实现IDeletionAudited（扩展了ISoftDelete），则删除时间和删除用户标识也由ASP.NET Boilerplate自动设置。

2， IMustHaveTenant

public class Product : Entity, IMustHaveTenant
{
public int TenantId { get; set; }

public string Name { get; set; }

}
IMustHaveTenant定义TenantId来区分不同的租户实体。 ASP.NET Boilerplate默认使用IAbpSession获取当前TenantId，并自动过滤当前租户的查询。

如果当前用户未登录到系统，或者当前用户是主机用户（主机用户是可管理租户和租户数据的上级用户），ASP.NET Boilerplate将自动禁用IMustHaveTenant过滤器。因此，所有租户的所有数据都可以被检索到应用程序

3，IMayHaveTenant（没有IMustHaveTenant常用）

public class Role : Entity, IMayHaveTenant
{
public int? TenantId { get; set; }

public string RoleName { get; set; }

}
空值表示这是主机实体，非空值表示由租户拥有的该实体，其ID为TenantId

4，禁用过滤器

var people1 = _personRepository.GetAllList();//访问未删除的

using (_unitOfWorkManager.Current.DisableFilter(AbpDataFilters.SoftDelete))
{
var people2 = _personRepository.GetAllList(); //访问所有的
}

var people3 = _personRepository.GetAllList();//访问未删除的
5，全局禁用过滤器
如果需要，可以全局禁用预定义的过滤器。例如，要全局禁用软删除过滤器，请将此代码添加到模块的PreInitialize方法中：

Configuration.UnitOfWork.OverrideFilter(AbpDataFilters.SoftDelete, false);
6，自定义过滤器

①定义过滤字段

public interface IHasPerson
{
int PersonId { get; set; }
}
②实体实现接口

public class Phone : Entity, IHasPerson
{
[ForeignKey(“PersonId”)]
public virtual Person Person { get; set; }
public virtual int PersonId { get; set; }

public virtual string Number { get; set; }

}
③定义过滤器

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);

modelBuilder.Filter("PersonFilter", (IHasPerson entity, int personId) => entity.PersonId == personId, 0);

}
“PersonFilter”是此处过滤器的唯一名称。第二个参数定义了过滤器接口和personId过滤器参数（如果过滤器不是参数，则不需要），最后一个参数是personId的默认值。

最后，我们必须在本模块的PreInitialize方法中向ASP.NET Boilerplate的工作单元注册此过滤器：

Configuration.UnitOfWork.RegisterFilter(“PersonFilter”, false);
第一个参数是我们之前定义的唯一的名称。第二个参数表示默认情况下是启用还是禁用此过滤器

using (CurrentUnitOfWork.EnableFilter(“PersonFilter”))
{
using(CurrentUnitOfWork.SetFilterParameter(“PersonFilter”, “personId”, 42))
{
var phones = _phoneRepository.GetAllList();
//…
}
}
我们可以从某个来源获取personId，而不是静态编码。以上示例是参数化过滤器。滤波器可以有零个或多个参数。如果没有参数，则不需要设置过滤器参数值。此外，如果默认情况下启用，则不需要手动启用它（当然，我们可以禁用它）。

十八、应用服务

1，CrudAppService和AsyncCrudAppService类

如果您需要创建一个应用程序服务，该服务将为特定实体创建“创建”，“更新”，“删除”，“获取”GetAll方法，则可以从CrudAppService继承（如果要创建异步方法，则可以继承AsyncCrudAppService）类来创建它。 CrudAppService基类是通用的，它将相关的实体和DTO类型作为通用参数，并且是可扩展的，允许您在需要自定义时重写功能。

①实体类

public class Task : Entity, IHasCreationTime
{
public string Title { get; set; }

public string Description { get; set; }

public DateTime CreationTime { get; set; }

public TaskState State { get; set; }

public Person AssignedPerson { get; set; }
public Guid? AssignedPersonId { get; set; }

public Task()
{
    CreationTime = Clock.Now;
    State = TaskState.Open;
}

}
②创建DTO

[AutoMap(typeof(Task))]
public class TaskDto : EntityDto, IHasCreationTime
{
public string Title { get; set; }

public string Description { get; set; }

public DateTime CreationTime { get; set; }

public TaskState State { get; set; }

public Guid? AssignedPersonId { get; set; }

public string AssignedPersonName { get; set; }

}
③应用服务

public class TaskAppService : AsyncCrudAppService<Task, TaskDto>,ITaskAppService
{ public TaskAppService(IRepository repository) : base(repository) { } }
④应用服务接口

public interface ITaskAppService : IAsyncCrudAppService
{

}
2，自定义CURD应用服务

1，查询

PagedAndSortedResultRequestDto，它提供可选的排序和分页参数。可以定义派生类过滤

public class GetAllTasksInput : PagedAndSortedResultRequestDto
{
public TaskState? State { get; set; }
}
现在，我们应该更改TaskAppService以应用自定义过滤器

public class TaskAppService : AsyncCrudAppService<Task, TaskDto, int, GetAllTasksInput>
{
public TaskAppService(IRepository repository)
: base(repository)
{

}

protected override IQueryable<Task> CreateFilteredQuery(GetAllTasksInput input)
{
    return base.CreateFilteredQuery(input)
        .WhereIf(input.State.HasValue, t => t.State == input.State.Value);
}

}
2，创建和更新

创建一个CreateTaskInput类

[AutoMapTo(typeof(Task))]
public class CreateTaskInput
{
[Required]
[MaxLength(Task.MaxTitleLength)]
public string Title { get; set; }

[MaxLength(Task.MaxDescriptionLength)]
public string Description { get; set; }

public Guid? AssignedPersonId { get; set; }

}
并创建一个UpdateTaskInput类

[AutoMapTo(typeof(Task))]
public class UpdateTaskInput : CreateTaskInput, IEntityDto
{
public int Id { get; set; }

public TaskState State { get; set; }

}
现在，我们可以将这些DTO类作为AsyncCrudAppService类的通用参数，如下所示：

public class TaskAppService : AsyncCrudAppService<Task, TaskDto, int, GetAllTasksInput, CreateTaskInput, UpdateTaskInput>
{
public TaskAppService(IRepository repository)
: base(repository)
{

}

protected override IQueryable<Task> CreateFilteredQuery(GetAllTasksInput input)
{
    return base.CreateFilteredQuery(input)
        .WhereIf(input.State.HasValue, t => t.State == input.State.Value);
}

}
3，CURD权限

您可能需要授权您的CRUD方法。您可以设置预定义的权限属性：GetPermissionName，GetAllPermissionName，CreatePermissionName，UpdatePermissionName和DeletePermissionName。如果您设置它们，基本CRUD类将自动检查权限。您可以在构造函数中设置它，如下所示：

public class TaskAppService : AsyncCrudAppService<Task, TaskDto>
{
public TaskAppService(IRepository repository)
: base(repository)
{
CreatePermissionName = “MyTaskCreationPermission”;
}
}
或者，您可以覆盖适当的权限检查方法来手动检查权限：CheckGetPermission（），CheckGetAllPermission（），CheckCreatePermission（），CheckUpdatePermission（），CheckDeletePermission（）。默认情况下，它们都调用具有相关权限名称的CheckPermission（…）方法，该方法只需调用IPermissionChecker.Authorize（…）方法即可。

十九、数据传输对象

1，帮助接口和类

ILimitedResultRequest定义MaxResultCount属性。因此，您可以在输入的DTO中实现它，以便对限制结果集进行标准化。

IPagedResultRequest通过添加SkipCount扩展ILimitedResultRequest。所以，我们可以在SearchPeopleInput中实现这个接口进行分页：

public class SearchPeopleInput : IPagedResultRequest
{
[StringLength(40, MinimumLength = 1)]
public string SearchedName { get; set; }

public int MaxResultCount { get; set; }
public int SkipCount { get; set; }

}

二十、验证数据传输对象

1，使用数据注解（System.ComponentModel.DataAnnotations）

public class CreateTaskInput
{
public int? AssignedPersonId { get; set; }

[Required]
public string Description { get; set; }

}
2，自定义验证

public class CreateTaskInput : ICustomValidate
{
public int? AssignedPersonId { get; set; }

public bool SendEmailToAssignedPerson { get; set; }

[Required]
public string Description { get; set; }

public void AddValidationErrors(CustomValidatationContext context)
{
    if (SendEmailToAssignedPerson && (!AssignedPersonId.HasValue || AssignedPersonId.Value <= 0))
    {
        context.Results.Add(new ValidationResult("AssignedPersonId must be set if SendEmailToAssignedPerson is true!"));
    }
}

}
3，Normalize方法在验证之后调用（并在调用方法之前）

public class GetTasksInput : IShouldNormalize
{
public string Sorting { get; set; }

public void Normalize()
{
    if (string.IsNullOrWhiteSpace(Sorting))
    {
        Sorting = "Name ASC";
    }
}

}

二十一、授权

1，定义权限

①不同的模块可以有不同的权限。一个模块应该创建一个派生自AuthorizationProvider的类来定义它的权限

public class MyAuthorizationProvider : AuthorizationProvider
{
public override void SetPermissions(IPermissionDefinitionContext context)
{
var administration = context.CreatePermission(“Administration”);

    var userManagement = administration.CreateChildPermission("Administration.UserManagement");
    userManagement.CreateChildPermission("Administration.UserManagement.CreateUser");

    var roleManagement = administration.CreateChildPermission("Administration.RoleManagement");
}

}

IPermissionDefinitionContext属性定义：

Name：一个系统内的唯一名称，最好为权限名称

Display name：一个可本地化的字符串，可以在UI中稍后显示权限

Description：一个可本地化的字符串，可用于显示权限的定义，稍后在UI中

MultiTenancySides：对于多租户申请，租户或主机可以使用许可。这是一个Flags枚举，因此可以在双方使用权限。

featureDependency：可用于声明对功能的依赖。因此，仅当满足特征依赖性时，才允许该权限。它等待一个对象实现IFeatureDependency。默认实现是SimpleFeatureDependency类。示例用法：new SimpleFeatureDependency（“MyFeatureName”）

②权限可以具有父权限和子级权限。虽然这并不影响权限检查，但可能有助于在UI中分组权限。

③创建授权提供者后，我们应该在我们的模块的PreInitialize方法中注册它：

Configuration.Authorization.Providers.Add();
2，检查权限

①使用AbpAuthorize特性

[AbpAuthorize(“Administration.UserManagement.CreateUser”)]
public void CreateUser(CreateUserInput input)
{
//如果未授予“Administration.UserManagement.CreateUser”权限，用户将无法执行此方法。
}
AbpAuthorize属性还会检查当前用户是否已登录（使用IAbpSession.UserId）。所以，如果我们为一个方法声明一个AbpAuthorize，它只检查登录：

[AbpAuthorize]
public void SomeMethod(SomeMethodInput input)
{
//如果用户无法登录，则无法执行此方法。
}
②Abp授权属性说明

ASP.NET Boilerplate使用动态方法截取功能进行授权。所以方法使用AbpAuthorize属性有一些限制。

不能用于私有方法。
不能用于静态方法。
不能用于非注入类的方法（我们必须使用依赖注入）。

此外

如果方法通过接口调用（如通过接口使用的应用程序服务），可以将其用于任何公共方法。
如果直接从类引用（如ASP.NET MVC或Web API控制器）调用，则该方法应该是虚拟的。
如果保护方法应该是虚拟的。

注意：有四种类型的授权属性：

在应用服务（应用层）中，我们使用Abp.Authorization.AbpAuthorize属性。
在MVC控制器（Web层）中，我们使用Abp.Web.Mvc.Authorization.AbpMvcAuthorize属性。
在ASP.NET Web API中，我们使用Abp.WebApi.Authorization.AbpApiAuthorize属性。
在ASP.NET Core中，我们使用Abp.AspNetCore.Mvc.Authorization.AbpMvcAuthorize属性。

③禁止授权

您可以通过将AbpAllowAnonymous属性添加到应用程序服务来禁用方法/类的授权。对MVC，Web API和ASP.NET核心控制器使用AllowAnonymous，这些框架是这些框架的本机属性。

④使用IPermissionChecker

虽然AbpAuthorize属性在大多数情况下足够好，但是必须有一些情况需要检查方法体中的权限。我们可以注入和使用IPermissionChecker，如下例所示：

public void CreateUser(CreateOrUpdateUserInput input)
{
if (!PermissionChecker.IsGranted(“Administration.UserManagement.CreateUser”))
{
throw new AbpAuthorizationException(“您无权创建用户！”);
}
//如果用户未授予“Administration.UserManagement.CreateUser”权限，则无法达到此目的。
}
当然，您可以编写任何逻辑，因为IsGranted只返回true或false（也有Async版本）。如果您只是检查权限并抛出如上所示的异常，则可以使用Authorize方法：

public void CreateUser(CreateOrUpdateUserInput input)
{
PermissionChecker.Authorize(“Administration.UserManagement.CreateUser”);
//如果用户未授予“Administration.UserManagement.CreateUser”权限，则无法达到此目的。
}
由于授权被广泛使用，ApplicationService和一些常见的基类注入并定义了PermissionChecker属性。因此，可以在不注入应用程序服务类的情况下使用权限检查器。

⑤Razor 视图

基本视图类定义IsGranted方法来检查当前用户是否具有权限。因此，我们可以有条件地呈现视图。例：

@if (IsGranted(“Administration.UserManagement.CreateUser”))
{
@L(“CreateNewUser”)
}
客户端（Javascript）
在客户端，我们可以使用在abp.auth命名空间中定义的API。在大多数情况下，我们需要检查当前用户是否具有特定权限（具有权限名称）。例：

abp.auth.isGranted(‘Administration.UserManagement.CreateUser’);
您还可以使用abp.auth.grantedPermissions获取所有授予的权限，或者使用abp.auth.allPermissions获取应用程序中的所有可用权限名称。在运行时检查其他人的abp.auth命名空间。

二十二、功能管理

大多数SaaS（多租户）应用程序都有具有不同功能的版本（包）。因此，他们可以向租户（客户）提供不同的价格和功能选项。

1，定义功能
检查前应定义特征。模块可以通过从FeatureProvider类派生来定义自己的特征。在这里，一个非常简单的功能提供者定义了3个功能：

public class AppFeatureProvider : FeatureProvider
{
public override void SetFeatures(IFeatureDefinitionContext context)
{
　　　　　//识别功能的唯一名称（作为字符串）.默认值
var sampleBooleanFeature = context.Create(“SampleBooleanFeature”, defaultValue: “false”);
sampleBooleanFeature.CreateChildFeature(“SampleNumericFeature”, defaultValue: “10”);
context.Create(“SampleSelectionFeature”, defaultValue: “B”);
}
}
创建功能提供者后，我们应该在模块的PreInitialize方法中注册，如下所示：

Configuration.Features.Providers.Add();
其他功能属性
虽然需要唯一的名称和默认值属性，但是有一些可选的属性用于详细控制。

Scope：FeatureScopes枚举中的值。它可以是版本（如果此功能只能为版本级设置），租户（如果此功能只能为租户级别设置）或全部（如果此功能可以为版本和租户设置，租户设置覆盖其版本的设置）。默认值为全部。
DisplayName：一个可本地化的字符串，用于向用户显示该功能的名称。
Description：一个可本地化的字符串，用于向用户显示该功能的详细说明。
InputType：功能的UI输入类型。这可以定义，然后可以在创建自动功能屏幕时使用。
Attributes：键值对的任意自定义词典可以与特征相关。

public class AppFeatureProvider : FeatureProvider
{
public override void SetFeatures(IFeatureDefinitionContext context)
{
var sampleBooleanFeature = context.Create(
AppFeatures.SampleBooleanFeature,
defaultValue: “false”,
displayName: L(“Sample boolean feature”),
inputType: new CheckboxInputType()
);

    sampleBooleanFeature.CreateChildFeature(
        AppFeatures.SampleNumericFeature,
        defaultValue: "10",
        displayName: L("Sample numeric feature"),
        inputType: new SingleLineStringInputType(new NumericValueValidator(1, 1000000))
        );

    context.Create(
        AppFeatures.SampleSelectionFeature,
        defaultValue: "B",
        displayName: L("Sample selection feature"),
        inputType: new ComboboxInputType(
            new StaticLocalizableComboboxItemSource(
                new LocalizableComboboxItem("A", L("Selection A")),
                new LocalizableComboboxItem("B", L("Selection B")),
                new LocalizableComboboxItem("C", L("Selection C"))
                )
            )
        );
}

private static ILocalizableString L(string name)
{
    return new LocalizableString(name, AbpZeroTemplateConsts.LocalizationSourceName);
}

}
功能层次结构
如示例功能提供者所示，功能可以具有子功能。父功能通常定义为布尔特征。子功能仅在启用父级时才可用。 ASP.NET Boilerplate不执行但建议这一点。应用程序应该照顾它。

2，检查功能

我们定义一个功能来检查应用程序中的值，以允许或阻止每个租户的某些应用程序功能。有不同的检查方式。

①使用RequiresFeature属性

[RequiresFeature(“ExportToExcel”)]
public async Task GetReportToExcel(…)
{
…
}
只有对当前租户启用了“ExportToExcel”功能（当前租户从IAbpSession获取），才执行此方法。如果未启用，则会自动抛出AbpAuthorizationException异常。

当然，RequiresFeature属性应该用于布尔类型的功能。否则，你可能会得到异常。

②RequiresFeature属性注释

ASP.NET Boilerplate使用动态方法截取功能进行功能检查。所以，方法使用RequiresFeature属性有一些限制。

不能用于私有方法。
不能用于静态方法。
不能用于非注入类的方法（我们必须使用依赖注入）。

此外

③使用IFeatureChecker
我们可以注入和使用IFeatureChecker手动检查功能（它自动注入并可直接用于应用程序服务，MVC和Web API控制器）。

public async Task GetReportToExcel(…)
{
if (await FeatureChecker.IsEnabledAsync(“ExportToExcel”))
{
throw new AbpAuthorizationException(“您没有此功能：ExportToExcel”);
}

...

}
如果您只想检查一个功能并抛出异常，如示例所示，您只需使用CheckEnabled方法即可。

④获取功能的值

var createdTaskCountInThisMonth = GetCreatedTaskCountInThisMonth();
if (createdTaskCountInThisMonth >= FeatureChecker.GetValue(“MaxTaskCreationLimitPerMonth”).To())
{
throw new AbpAuthorizationException(“你超过本月的任务创建限制”);
}
FeatureChecker方法也覆盖了指定tenantId的工作功能，不仅适用于当前的tenantId。

⑤客户端
在客户端（javascript）中，我们可以使用abp.features命名空间来获取当前的功能值。

var isEnabled = abp.features.isEnabled(‘SampleBooleanFeature’);
var value = abp.features.getValue(‘SampleNumericFeature’);

是刘彦宏吖

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
ABP框架概念

二、领域层10，实体11，值对象12，仓储13，领域服务14，规格模式15，工作单元16，事件总线17，数据过滤器三、应用层18，应用服务19，数据传输对象20，验证数据传输对象21，授权22，功能管理23，审计日志四、分布式服务层24，ASP.NET Web API Controllers25，动态Webapi层26，OData整合27，Swagger UI 整合10，实体实体具有Id并存储在数据库中，实体通常映射到关系数据库的表。1，审计接口①当Ent
复制链接

扫一扫