ABP 数据访问 - IRepository 仓储

ABP系列，这个系列来的比较晚，很多大佬其实已经分析过，为什么现在我又来一轮呢？

1.想自己来完整的学习一轮ABP

2.公司目前正在使用ABP，准备迁移Core

基于以上的目的，开始这个系列

ABP IRepository

先上 IRepository 类图结构

只是描述了类的关联关系，很多成员并不准确

基于这个类图，我们再来分析下ABP的仓储访问；

1.IRepository 整体结构

按照我的理解，可以简单分为三部分；

1.整体接口以及抽象父类定义

2.自定义DbContext，Repository，实体

3.自动注册实体仓储

1.整体接口以及抽象父类定义

这部分内容整体包含在IRepository,IRepository<TEntity,TprimaryKey>,AbpRepositoryBase中，也就是图中为包含在虚线框的内容；

IRepository：仓储的接口，接口中未定义方方法

IRepository<TEntity, TPrimaryKey> ：定义仓储对象的相关查询方法，GetAll(),Get()等方法

AbpRepositoryBase<TEntity, TPrimaryKey> ：抽象类，封装了一些公共方法但是并未有具体实现，实现留在了具体的调用层，例如 EF，EfCore，Dapper等

接口实现

EfCoreRepositoryBase<TDbContext, TEntity, TPrimaryKey> ：

实现AbpRepositoryBase<TEntity, TPrimaryKey>

1.EFCore的内部核心查询全部就依赖于 DbContext，DbSet来操作数据；

2.EFCore的DbContext引用来源Microsoft.EntityFrameworkCore.DbContext,而Ef的DbContext依赖引用System.Data.Entity.DbContext，Core的底层依赖就全部替换了

AbpDbContext ：ABP默认的EFCore的DBContext封装，包含一些公共方法，要在ABP框架下使用DbContext,需要继承 AbpDbContext

2.自定义DbContext，Repository，实体

实现DBContext：

 public class SampleAppDbContext : AbpZeroDbContext<Tenant, Role, User, SampleAppDbContext>, IAbpPersistedGrantDbContext
    {
        public DbSet<PersistedGrantEntity> PersistedGrants { get; set; }
        public DbSet<Advertisement> Advertisements { get; set; }
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }
        public DbSet<Category> Categories { get; set; }
        public DbSet<Comment> Comments { get; set; }
        public DbSet<Product> Products { get; set; }
        public DbSet<ProductTranslation> ProductTranslations { get; set; }
        public DbSet<Author> Authors { get; set; }
        public DbSet<Store> Stores { get; set; }
        public DbSet<Order> Orders { get; set; }
        public DbSet<OrderTranslation> OrderTranslations { get; set; }
        public DbSet<UserTestEntity> UserTestEntities { get; set; }
        public DbSet<Country> Countries { get; set; }
        public SampleAppDbContext(DbContextOptions<SampleAppDbContext> options)
            : base(options)
        {
        }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.ConfigurePersistedGrantEntity();
            modelBuilder.Entity<Blog>().OwnsOne(x => x.More);
            modelBuilder.Entity<Blog>().OwnsMany(x => x.Promotions, b =>
            {
                b.WithOwner().HasForeignKey(bp => bp.BlogId);
                b.Property<int>("Id");
                b.HasKey("Id");
                b.HasOne<Blog>()
                 .WithOne()
                 .HasForeignKey<BlogPromotion>(bp => bp.AdvertisementId)
                 .IsRequired();
            });
            modelBuilder.Entity<Advertisement>().OwnsMany(a => a.Feedbacks, b =>
            {
                b.WithOwner().HasForeignKey(af => af.AdvertisementId);
               b.Property<int>("Id");
                b.HasKey("Id");
                b.HasOne<Comment>()
                 .WithOne()
                 .HasForeignKey<AdvertisementFeedback>(af => af.CommentId);
            });
            modelBuilder.Entity<Book>().ToTable("Books");
            modelBuilder.Entity<Book>().Property(e => e.Id).ValueGeneratedNever();
            modelBuilder.Entity<Store>().Property(e => e.Id).HasColumnName("StoreId");
        }
    }
}

DbContext中需要定义实体的DBSet，因为数据操作都是基于DbSet来完成

个性化仓储：

第一步，设置自定义仓储接口

  public interface IPostRepository : IRepository<Post, Guid>
    {
    }

这里继承IRepository<Entity,PrimaryKey>,说明实体主键并非Int类型，所以需要重新实现

第二步，继承 EfCoreRepositoryBase，实现自定义仓储方法

 public class PostRepository : EfCoreRepositoryBase<BloggingDbContext, Post, Guid>,
IPostRepository
    {
        public PostRepository(IDbContextProvider<BloggingDbContext> dbContextProvider)
            : base(dbContextProvider)
        {
        }
        public override int Count()
        {
            throw new Exception("can not get count of posts");
        }
    }

第三步，注册自定义仓储，注册代码写在自定义模块中

注意：自定义模块的注册必须依赖 AbpEntityFrameworkCoreModule 模块先注册 这里留着后面来解释，为什么一定要依赖

//Custom repository

            Configuration.ReplaceService<IRepository<Post, Guid>>(() =>
            {
                IocManager.IocContainer.Register(
                    Component.For<IRepository<Post, Guid>, IPostRepository,
PostRepository>()
                        .ImplementedBy<PostRepository>()
                        .LifestyleTransient()
                );
            });

3.自动注册实体仓储

首先来看下，我们定义好DbContext后，如果使用自己的仓储服务呢？

在类里面定义属性仓储

private readonly IRepository<EntityDynamicParameter> _entityDynamicParameterRepository;

大家有没有考虑过，为什么我们可以直接使用实体的仓储类，在哪里实例化的呢？ 这是ABP自动完成的，会反射获取所有的实体服务，并自动为其注册仓储服务，我们一起来分析下自动注册的内容

AbpEntityFrameworkCoreModule.cs

public override void Initialize()
        {           
IocManager.RegisterAssemblyByConvention(typeof(AbpEntityFrameworkCoreModule).GetAssembly());
            IocManager.IocContainer.Register(
                Component.For(typeof(IDbContextProvider<>))
           .ImplementedBy(typeof(UnitOfWorkDbContextProvider<>))
                    .LifestyleTransient()
                );
            RegisterGenericRepositoriesAndMatchDbContexes();
        }

调用 RegisterGenericRepositoriesAndMatchDbContexes 方法

        private void RegisterGenericRepositoriesAndMatchDbContexes()
        {
            var dbContextTypes =
                _typeFinder.Find(type =>
                {
                    var typeInfo = type.GetTypeInfo();
                    return typeInfo.IsPublic &&
                           !typeInfo.IsAbstract &&
                           typeInfo.IsClass &&
                           typeof(AbpDbContext).IsAssignableFrom(type);
                });
            if (dbContextTypes.IsNullOrEmpty())
            {
                Logger.Warn("No class found derived from AbpDbContext.");
                return;
            }
            using (IScopedIocResolver scope = IocManager.CreateScope())
            {
                foreach (var dbContextType in dbContextTypes)
                {
                    Logger.Debug("Registering DbContext: " + dbContextType.AssemblyQualifiedName);                  
                    scope.Resolve<IEfGenericRepositoryRegistrar>().RegisterForDbContext(dbContextType, IocManager, EfCoreAutoRepositoryTypes.Default);
                    IocManager.IocContainer.Register(
                    Component.For<ISecondaryOrmRegistrar>()
                            .Named(Guid.NewGuid().ToString("N"))
                            .Instance(new EfCoreBasedSecondaryOrmRegistrar(dbContextType, scope.Resolve<IDbContextEntityFinder>()))
                            .LifestyleTransient()
                    );
                }
                scope.Resolve<IDbContextTypeMatcher>().Populate(dbContextTypes);
            }
        }

1.首先加载所有的AbpDbContext

2.对AbpDbContext循环进行注册

这里的注册依赖接口

scope.Resolve().RegisterForDbContext(dbContextType, IocManager, EfCoreAutoRepositoryTypes.Default);

我们来看下这个具体实现逻辑，依赖接口 IEfGenericRepositoryRegistrar

EfGenericRepositoryRegistrar.cs

public void RegisterForDbContext(
            Type dbContextType,
            IIocManager iocManager,
            AutoRepositoryTypesAttribute defaultAutoRepositoryTypesAttribute)
        {
            var autoRepositoryAttr = dbContextType.GetTypeInfo().GetSingleAttributeOrNull<AutoRepositoryTypesAttribute>() ?? defaultAutoRepositoryTypesAttribute;
            RegisterForDbContext(
                dbContextType,
                iocManager,
                autoRepositoryAttr.RepositoryInterface,
                autoRepositoryAttr.RepositoryInterfaceWithPrimaryKey,
                autoRepositoryAttr.RepositoryImplementation,
                autoRepositoryAttr.RepositoryImplementationWithPrimaryKey
            );
            if (autoRepositoryAttr.WithDefaultRepositoryInterfaces)
            {
                RegisterForDbContext(
                    dbContextType,
                    iocManager,
                    defaultAutoRepositoryTypesAttribute.RepositoryInterface,
                    defaultAutoRepositoryTypesAttribute.RepositoryInterfaceWithPrimaryKey,
                    autoRepositoryAttr.RepositoryImplementation,
                    autoRepositoryAttr.RepositoryImplementationWithPrimaryKey
                );
            }
        }

private void RegisterForDbContext(
            Type dbContextType,
            IIocManager iocManager,
            Type repositoryInterface,
            Type repositoryInterfaceWithPrimaryKey,
            Type repositoryImplementation,
            Type repositoryImplementationWithPrimaryKey)
        {
            foreach (var entityTypeInfo in _dbContextEntityFinder.GetEntityTypeInfos(dbContextType))
            {
                var primaryKeyType = EntityHelper.GetPrimaryKeyType(entityTypeInfo.EntityType);
                if (primaryKeyType == typeof(int))
                {
                    var genericRepositoryType = repositoryInterface.MakeGenericType(entityTypeInfo.EntityType);
                    if (!iocManager.IsRegistered(genericRepositoryType))
                    {
                        var implType = repositoryImplementation.GetGenericArguments().Length == 1 ? repositoryImplementation.MakeGenericType(entityTypeInfo.EntityType) : repositoryImplementation.MakeGenericType(entityTypeInfo.DeclaringType,
                                entityTypeInfo.EntityType);
                        iocManager.IocContainer.Register(
                            Component
                                .For(genericRepositoryType)
                                .ImplementedBy(implType)
                                .Named(Guid.NewGuid().ToString("N"))
                                .LifestyleTransient()
                        );
                    }
                }
                var genericRepositoryTypeWithPrimaryKey =
repositoryInterfaceWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType,primaryKeyType);
                if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
                {
                    var implType =
repositoryImplementationWithPrimaryKey.GetGenericArguments().Length == 2? repositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.EntityType, primaryKeyType) : repositoryImplementationWithPrimaryKey.MakeGenericType(entityTypeInfo.DeclaringType, entityTypeInfo.EntityType, primaryKeyType);
                    iocManager.IocContainer.Register(
                        Component
                            .For(genericRepositoryTypeWithPrimaryKey)
                            .ImplementedBy(implType)
                            .Named(Guid.NewGuid().ToString("N"))
                            .LifestyleTransient()
                    );
                }
            }
        }

来分析下具体的实现逻辑

foreach (var entityTypeInfo in _dbContextEntityFinder.GetEntityTypeInfos(dbContextType))

_dbContextEntityFinder.GetEntityTypeInfos(dbContextType) 这里获取的就是DbContext定义的实体DbSet，从而获取到每个实体，用来做后续的仓储注入；例如：获取到了 PersonEntity

 var primaryKeyType = EntityHelper.GetPrimaryKeyType(entityTypeInfo.EntityType);

获取实体主键

if (primaryKeyType == typeof(int))

判断主键是否为int，如果是int，则继承 IRepository，否则继承IRepository<Entity,PrimaryKey>用来重写主键

那是通过什么类来实现的IRepository呢？

public static AutoRepositoryTypesAttribute Default { get; }
        static EfCoreAutoRepositoryTypes()
        {
            Default = new AutoRepositoryTypesAttribute(
                typeof(IRepository<>),
                typeof(IRepository<,>),
                typeof(EfCoreRepositoryBase<,>),
                typeof(EfCoreRepositoryBase<,,>)
            );
        }

这是默认的实体继承的仓储类，EfCoreRepositoryBase 类

好了，实体的默认仓储就介绍完毕了。。。 不对啊，这里可以满足我们的DbContext里面所有的实体，但是万一有了自定义仓储呢？怎么注册自己的仓储呢？

哈哈，其实还是有个方法的，而且还不只一个。。。

1.DbContext打标记，用来替换默认的AutoRepositoryTypesAttribute

[AutoRepositoryTypes(
            typeof(IMyModuleRepository<>),
            typeof(IMyModuleRepository<,>),
            typeof(MyModuleRepositoryBase<>),
            typeof(MyModuleRepositoryBase<,>)
            )]

2.第二种就是替换已经注册的实体仓储服务

回到上面问题，AbpEntityFrameworkCoreModule 模块先注册 ？ 其实上面写到了，在我们自定义的模块注册时，可以重新注册仓储服务

//Custom repository

            Configuration.ReplaceService<IRepository<Post, Guid>>(() =>
            {
                IocManager.IocContainer.Register(
                    Component.For<IRepository<Post, Guid>, IPostRepository,
PostRepository>()
                        .ImplementedBy<PostRepository>()
                        .LifestyleTransient()
                );
            });

就是要必须在 AbpEntityFrameworkCoreModule 注册之后，否则就会被覆盖哦，这里也就呼应了上面的问题了

仓储三要素：

1. 仓储的生命周期：仓储都是临时性的，需要的时候创建，用完销毁。
2. 数据库的连接和管理仓储的方法中，数据库的连接和管理都是由ABP框架自动处理的。当方法被调用的时候，ABP自动开启数据库的连接同时开启事务，当方法结束后，ABP会将实体数据保存，然后断开连接。当在仓储方法中调用仓储方法的时候，此时只会创建一个数据库连接，他们共同享用数据库连接和事务，由最上层的那个仓储方法进行管理。
3. 仓储的最佳实践在ABP框架初始化的时候已经为每一个实体类都默认的实现了相应的仓储，这些仓储里的方法基本可以满足日常的开发需求，所以不要自己手动创建仓储