简介

仓储模式（Repository Pattern）是一种数据访问抽象模式，它在领域模型和数据访问层之间创建了一个隔离层，使得领域模型无需直接与数据访问逻辑交互。仓储模式的核心思想是将数据访问逻辑封装在一个独立的组件中，使业务逻辑与数据访问解耦。

仓储模式核心概念

仓储模式定义

仓储（Repository）是一个领域对象的集合抽象，它：

• 封装数据访问细节
• 提供领域对象集合的接口
• 隔离业务逻辑与数据存储技术

与传统数据访问层对比

仓储模式的核心作用

解耦业务逻辑与数据访问

• 业务层不需要依赖具体的数据访问技术（如 Entity Framework、Dapper 等）
• 更换数据存储方式时（如从 SQL Server 切换到 MongoDB），无需修改业务逻辑

提高可测试性

• 可以通过实现仓储接口的模拟对象（Mock）进行单元测试
• 隔离外部依赖，使测试更专注于业务逻辑

统一数据访问接口

• 为不同的实体提供一致的数据操作方法（如 CRUD ）
• 简化数据访问代码，减少重复工作

支持领域驱动设计（DDD）

• 作为领域模型与数据持久化之间的桥梁
• 帮助实现聚合根（Aggregate Root）的概念

仓储模式实现详解

基础接口定义

public interface IRepository<TEntity> where TEntity : class
{
    // 查询操作
    TEntity GetById(int id);
    Task<TEntity> GetByIdAsync(int id);
    IEnumerable<TEntity> GetAll();
    Task<IEnumerable<TEntity>> GetAllAsync();
    IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);
    
    // 修改操作
    void Add(TEntity entity);
    Task AddAsync(TEntity entity);
    void AddRange(IEnumerable<TEntity> entities);
    void Update(TEntity entity);
    void Remove(TEntity entity);
    void RemoveRange(IEnumerable<TEntity> entities);
    
    // 聚合函数
    int Count(Expression<Func<TEntity, bool>> predicate = null);
    bool Any(Expression<Func<TEntity, bool>> predicate);
}

泛型仓储实现 (EF Core)

public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{
    protected readonly DbContext _context;
    protected readonly DbSet<TEntity> _dbSet;

    public Repository(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<TEntity>();
    }

    public virtual TEntity GetById(int id) => 
        _dbSet.Find(id);

    public virtual async Task<TEntity> GetByIdAsync(int id) => 
        await _dbSet.FindAsync(id);

    public virtual IEnumerable<TEntity> GetAll() => 
        _dbSet.ToList();

    public virtual async Task<IEnumerable<TEntity>> GetAllAsync() => 
        await _dbSet.ToListAsync();

    public virtual IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate) => 
        _dbSet.Where(predicate).ToList();

    public virtual void Add(TEntity entity) => 
        _dbSet.Add(entity);

    public virtual async Task AddAsync(TEntity entity) => 
        await _dbSet.AddAsync(entity);

    public virtual void AddRange(IEnumerable<TEntity> entities) => 
        _dbSet.AddRange(entities);

    public virtual void Update(TEntity entity) => 
        _context.Entry(entity).State = EntityState.Modified;

    public virtual void Remove(TEntity entity) => 
        _dbSet.Remove(entity);

    public virtual void RemoveRange(IEnumerable<TEntity> entities) => 
        _dbSet.RemoveRange(entities);

    public virtual int Count(Expression<Func<TEntity, bool>> predicate = null) => 
        predicate == null ? _dbSet.Count() : _dbSet.Count(predicate);

    public virtual bool Any(Expression<Func<TEntity, bool>> predicate) => 
        _dbSet.Any(predicate);
}

工作单元(Unit of Work)模式集成

public interface IUnitOfWork : IDisposable
{
    IRepository<TEntity> GetRepository<TEntity>() where TEntity : class;
    Task<int> CommitAsync();
    int Commit();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly DbContext _context;
    private Dictionary<Type, object> _repositories;

    public UnitOfWork(DbContext context)
    {
        _context = context;
        _repositories = new Dictionary<Type, object>();
    }

    public IRepository<TEntity> GetRepository<TEntity>() where TEntity : class
    {
        if (_repositories.ContainsKey(typeof(TEntity)))
            return (IRepository<TEntity>)_repositories[typeof(TEntity)];
        
        var repository = new Repository<TEntity>(_context);
        _repositories.Add(typeof(TEntity), repository);
        return repository;
    }

    public async Task<int> CommitAsync() => 
        await _context.SaveChangesAsync();

    public int Commit() => 
        _context.SaveChanges();

    public void Dispose() => 
        _context.Dispose();
}

高级应用

特定领域仓储

// 用户领域特定接口
public interface IUserRepository : IRepository<User>
{
    User GetByEmail(string email);
    Task<User> GetByUsernameAsync(string username);
    IEnumerable<User> GetActiveUsers();
    Task<int> CountActiveUsersAsync();
}

// 具体实现
public class UserRepository : Repository<User>, IUserRepository
{
    public UserRepository(AppDbContext context) : base(context) { }

    public User GetByEmail(string email) => 
        _context.Users.FirstOrDefault(u => u.Email == email);

    public async Task<User> GetByUsernameAsync(string username) => 
        await _context.Users.FirstOrDefaultAsync(u => u.Username == username);

    public IEnumerable<User> GetActiveUsers() => 
        _context.Users.Where(u => u.IsActive).ToList();

    public async Task<int> CountActiveUsersAsync() => 
        await _context.Users.CountAsync(u => u.IsActive);
}

规范模式(Specification)集成

// 规范接口
public interface ISpecification<T>
{
    Expression<Func<T, bool>> Criteria { get; }
    List<Expression<Func<T, object>>> Includes { get; }
    Expression<Func<T, object>> OrderBy { get; }
    Expression<Func<T, object>> OrderByDescending { get; }
}

// 仓储扩展
public static class RepositoryExtensions
{
    public static IQueryable<T> ApplySpecification<T>(this IRepository<T> repository, ISpecification<T> spec) 
        where T : class
    {
        var query = repository.GetQueryable();
        
        // 包含关联实体
        if (spec.Includes != null)
        {
            query = spec.Includes.Aggregate(
                query, (current, include) => current.Include(include));
        }
        
        // 应用条件
        if (spec.Criteria != null)
        {
            query = query.Where(spec.Criteria);
        }
        
        // 排序
        if (spec.OrderBy != null)
        {
            query = query.OrderBy(spec.OrderBy);
        }
        else if (spec.OrderByDescending != null)
        {
            query = query.OrderByDescending(spec.OrderByDescending);
        }
        
        return query;
    }
}

分页查询支持

public class PagedResult<T>
{
    public int TotalCount { get; set; }
    public int PageNumber { get; set; }
    public int PageSize { get; set; }
    public List<T> Items { get; set; }
}

public static class RepositoryExtensions
{
    public static async Task<PagedResult<T>> GetPagedAsync<T>(
        this IRepository<T> repository,
        Expression<Func<T, bool>> filter = null,
        int pageNumber = 1,
        int pageSize = 10,
        Expression<Func<T, object>> orderBy = null,
        bool ascending = true) where T : class
    {
        var query = repository.GetQueryable();
        
        if (filter != null)
            query = query.Where(filter);
        
        var totalCount = await query.CountAsync();
        
        if (orderBy != null)
        {
            query = ascending ? 
                query.OrderBy(orderBy) : 
                query.OrderByDescending(orderBy);
        }
        
        var items = await query
            .Skip((pageNumber - 1) * pageSize)
            .Take(pageSize)
            .ToListAsync();
        
        return new PagedResult<T>
        {
            TotalCount = totalCount,
            PageNumber = pageNumber,
            PageSize = pageSize,
            Items = items
        };
    }
}

最佳实践

依赖注入配置

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // 注册DbContext
    services.AddDbContext<AppDbContext>(options => 
        options.UseSqlServer(Configuration.GetConnectionString("Default")));
    
    // 注册泛型仓储
    services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
    
    // 注册工作单元
    services.AddScoped<IUnitOfWork, UnitOfWork>();
    
    // 注册特定领域仓储
    services.AddScoped<IUserRepository, UserRepository>();
    services.AddScoped<IOrderRepository, OrderRepository>();
}

服务层使用示例

public class UserService
{
    private readonly IUserRepository _userRepository;
    private readonly IUnitOfWork _unitOfWork;

    public UserService(IUserRepository userRepository, IUnitOfWork unitOfWork)
    {
        _userRepository = userRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<User> RegisterUser(UserRegistrationDto dto)
    {
        if (await _userRepository.Any(u => u.Email == dto.Email))
            throw new Exception("Email already exists");
        
        var user = new User
        {
            Username = dto.Username,
            Email = dto.Email,
            PasswordHash = HashPassword(dto.Password)
        };
        
        _userRepository.Add(user);
        await _unitOfWork.CommitAsync();
        
        return user;
    }
    
    public async Task<PagedResult<User>> GetActiveUsers(int page, int pageSize)
    {
        return await _userRepository.GetPagedAsync(
            filter: u => u.IsActive,
            pageNumber: page,
            pageSize: pageSize,
            orderBy: u => u.CreatedDate,
            ascending: false);
    }
}

性能优化技巧

// 1. 使用异步操作
await _userRepository.GetByIdAsync(id);

// 2. 禁用变更跟踪（只读查询）
var users = await _userRepository
    .GetQueryable()
    .AsNoTracking()
    .Where(u => u.IsActive)
    .ToListAsync();

// 3. 批量操作
_userRepository.AddRange(users);
await _unitOfWork.CommitAsync();

// 4. 延迟加载避免（使用Include预加载）
var userWithOrders = await _userRepository
    .GetQueryable()
    .Include(u => u.Orders)
    .FirstOrDefaultAsync(u => u.Id == userId);

在工作单元中实现事务

public async Task CreateOrderWithTransaction(Order order, Payment payment)
{
    using var transaction = await _unitOfWork.BeginTransactionAsync();
    
    try
    {
        _orderRepository.Add(order);
        _paymentRepository.Add(payment);
        
        await _unitOfWork.CommitAsync();
        await transaction.CommitAsync();
    }
    catch
    {
        await transaction.RollbackAsync();
        throw;
    }
}

测试策略

// 使用Moq测试仓储
[Fact]
public async Task RegisterUser_Should_AddNewUser()
{
    // 准备
    var mockRepo = new Mock<IUserRepository>();
    var mockUnit = new Mock<IUnitOfWork>();
    var service = new UserService(mockRepo.Object, mockUnit.Object);
    
    var dto = new UserRegistrationDto { /* ... */ };
    
    // 执行
    var user = await service.RegisterUser(dto);
    
    // 断言
    mockRepo.Verify(r => r.Add(It.IsAny<User>()), Times.Once);
    mockUnit.Verify(u => u.CommitAsync(), Times.Once);
    Assert.NotNull(user);
}

高级用法

缓存集成

public class CachedUserRepository : IUserRepository
{
    private readonly IUserRepository _decorated;
    private readonly IDistributedCache _cache;
    
    public CachedUserRepository(IUserRepository decorated, IDistributedCache cache)
    {
        _decorated = decorated;
        _cache = cache;
    }
    
    public async Task<User> GetByIdAsync(int id)
    {
        var cacheKey = #34;user_{id}";
        var user = await _cache.GetAsync<User>(cacheKey);
        
        if (user != null) return user;
        
        user = await _decorated.GetByIdAsync(id);
        if (user != null)
        {
            await _cache.SetAsync(cacheKey, user, new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
            });
        }
        
        return user;
    }
    
    // 其他方法委托给_decorated实现...
}

多数据库支持

public class HybridOrderRepository : IOrderRepository
{
    private readonly SqlOrderRepository _sqlRepo;
    private readonly CosmosOrderRepository _cosmosRepo;
    
    public HybridOrderRepository(
        SqlOrderRepository sqlRepo, 
        CosmosOrderRepository cosmosRepo)
    {
        _sqlRepo = sqlRepo;
        _cosmosRepo = cosmosRepo;
    }
    
    public async Task AddAsync(Order order)
    {
        // 写操作到两个数据库
        await _sqlRepo.AddAsync(order);
        await _cosmosRepo.AddAsync(order);
    }
    
    public async Task<Order> GetByIdAsync(int id)
    {
        // 优先从缓存数据库读取
        var order = await _cosmosRepo.GetByIdAsync(id);
        return order ?? await _sqlRepo.GetByIdAsync(id);
    }
}

场景

推荐使用场景

• 领域驱动设计(DDD)：聚合根持久化
• 复杂业务系统：多数据源协调
• 可测试性要求高：业务逻辑单元测试
• 多数据源支持：混合SQL/NoSQL/API
• 架构演进：准备替换数据访问技术

不推荐使用场景

• 简单CRUD应用：增加不必要复杂度
• 高性能要求：直接使用原始 SQL 更高效
• 微服务简单查询：CQRS 模式更合适
• 小型项目：YAGNI 原则（不需要就不要加）