前言
公司之前使用Ado.net和Dapper进行数据访问层的操作, 进行读写分离也比较简单, 只要使用对应的数据库连接字符串即可. 而最近要迁移到新系统中,新系统使用.net core和EF Core进行数据访问. 所以趁着国庆假期拿出一两天时间研究了一下如何EF Core进行读写分离.
思路
根据园子里的Jeffcky大神的博客, 参考
EntityFramework Core进行读写分离最佳实践方式，了解一下（一）？
EntityFramework Core进行读写分离最佳实践方式，了解一下（二）？
最简单的思路就是使用手动切换EF Core上下文的连接, 即context.Database.GetDbConnection().ConnectionString = "xxx", 但必须要先创建上下文, 再关闭之前的连接, 才能进行切换
另一种方式是通过监听Diagnostic来将进行查询的sql切换到从库执行, 这种方式虽然可以实现无感知的切换操作, 但不能满足公司的业务需求. 在后台管理或其他对数据实时性要求比较高的项目里,查询操作也都应该走主库,而这种方式却会切换到从库去. 另一方面就是假若公司的库比较多,每种业务都对应了一个库, 每个库都对应了一种DbContext, 这种情况下, 要实现自动切换就变得很复杂了.
上面的两种方式都是从切换数据库连接入手,但是频繁的切换数据库连接势必会对性能造成影响. 我认为最理想的方式是要避免数据库连接的切换, 且能够适应多DbContext的情况, 在创建上下文实例时,就指定好是访问主库还是从库, 而不是在后期再进行数据库切换. 因此, 在上下文实例化时,就传入相应的数据库连接字符串, 这样一来DbContext的创建就需要交由我们自己来进行, 就不是由DI容器进行创建了. 同时仓储应该区分为只读和可读可写两种,以防止其他人对从库进行写操作.
实现
public interface IReadOnlyRepository
where TEntity : class, IEntity
where TKey : IEquatable
{}
public interface IRepository : IReadOnlyRepository
where TEntity : class, IEntity
where TKey : IEquatable
{} IReadOnlyRepository接口是只读仓储接口,提供查询相关方法,IRepository接口是可读可写仓储接口,提供增删查改等方法, 接口的实现就那些东西这里就省略了.
public interface IRepositoryFactory
{
IRepository GetRepository(IUnitOfWork unitOfWork)
where TEntity : class, IEntity
where TKey : IEquatable;
IReadOnlyRepository GetReadOnlyRepository(IUnitOfWork unitOfWork)
where TEntity : class, IEntity
where TKey : IEquatable;
}
public class RepositoryFactory : IRepositoryFactory
{
public RepositoryFactory()
{
}
public IRepository GetRepository(IUnitOfWork unitOfWork)
where TEntity : class, IEntity
where TKey : IEquatable
{
return new Repository(unitOfWork);
}
public IReadOnlyRepository GetReadOnlyRepository(IUnitOfWork unitOfWork)
where TEntity : class, IEntity
where TKey : IEquatable
{
return new ReadOnlyRepository(unitOfWork);
}
} RepositoryFactory提供仓储对象的实例化
public interface IUnitOfWork : IDisposable
{
public DbContext DbContext { get; }
///
/// 获取只读仓储对象
///
IReadOnlyRepository GetReadOnlyRepository()
where TEntity : class, IEntity
where TKey : IEquatable;
///
/// 获取仓储对象
///
IRepository GetRepository()
where TEntity : class, IEntity
where TKey : IEquatable;
int SaveChanges();
Task SaveChangesAsync(CancellationToken cancelToken = default);
}
public class UnitOfWork : IUnitOfWork
{
private readonly IServiceProvider _serviceProvider;
private readonly DbContext _dbContext;
private readonly IRepositoryFactory _repositoryFactory;
private bool _disposed;
public UnitOfWork(IServiceProvider serviceProvider, DbContext context)
{
Check.NotNull(serviceProvider, nameof(serviceProvider));
_serviceProvider = serviceProvider;
_dbContext = context;
_repositoryFactory = serviceProvider.GetRequiredService();
}
public DbContext DbContext { get => _dbContext; }
public IReadOnlyRepository GetReadOnlyRepository()
where TEntity : class, IEntity
where TKey : IEquatable
{
return _repositoryFactory.GetReadOnlyRepository(this);
}
public IRepository GetRepository()
where TEntity : class, IEntity
where TKey : IEquatable
{
return _repositoryFactory.GetRepository(this);
}
public void Dispose()
{
if (_disposed)
{
return;
}
_dbContext?.Dispose();
_disposed = true;
}
// 其他略
} ///
/// 数据库提供者接口
///
public interface IDbProvider : IDisposable
{
///
/// 根据上下文类型及数据库名称获取UnitOfWork对象, dbName为null时默认为第一个数据库名称
///
IUnitOfWork GetUnitOfWork(Type dbContextType, string dbName = null);
}IDbProvider 接口, 根据上下文类型和配置文件中的数据库连接字符串名称创建IUnitOfWork, 在DI中的生命周期是Scoped,在销毁的同时会销毁数据库上下文对象, 下面是它的实现, 为了提高性能使用了Expression来代替反射.
public class DbProvider : IDbProvider
{
private readonly IServiceProvider _serviceProvider;
private readonly ConcurrentDictionary _works = new ConcurrentDictionary();
private static ConcurrentDictionary> _expressionFactoryDict =
new ConcurrentDictionary>();
public DbProvider(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
}
public IUnitOfWork GetUnitOfWork(Type dbContextType, string dbName = null)
{
var key = string.Format("{0}${1}$", dbName, dbContextType.FullName);
IUnitOfWork unitOfWork;
if (_works.TryGetValue(key, out unitOfWork))
{
return unitOfWork;
}
else
{
DbContext dbContext;
var dbConnectionOptionsMap = _serviceProvider.GetRequiredService>().Value.DbConnections;
if (dbConnectionOptionsMap == null || dbConnectionOptionsMap.Count <= 0)
{
throw new Exception("无法获取数据库配置");
}
DbConnectionOptions dbConnectionOptions = dbName == null ? dbConnectionOptionsMap.First().Value : dbConnectionOptionsMap[dbName];
var builderOptions = _serviceProvider.GetServices()
?.Where(d => (d.DbName == null || d.DbName == dbName) && (d.DbContextType == null || d.DbContextType == dbContextType))
?.OrderByDescending(d => d.DbName)
?.OrderByDescending(d => d.DbContextType);
if (builderOptions == null || !builderOptions.Any())
{
throw new Exception("无法获取匹配的DbContextOptionsBuilder");
}
var dbUser = _serviceProvider.GetServices()?.FirstOrDefault(u => u.Type == dbConnectionOptions.DatabaseType);
if (dbUser == null)
{
throw new Exception($"无法解析类型为“{dbConnectionOptions.DatabaseType}”的 {typeof(IDbContextOptionsBuilderUser).FullName} 实例");
}
var dbContextOptions = dbUser.Use(builderOptions.First().Builder, dbConnectionOptions.ConnectionString).Options;
if (_expressionFactoryDict.TryGetValue(dbContextType, out Func factory))
{
dbContext = factory(_serviceProvider, dbContextOptions);
}
else
{
// 使用Expression创建DbContext
var constructorMethod = dbContextType.GetConstructors()
.Where(c => c.IsPublic && !c.IsAbstract && !c.IsStatic)
.OrderByDescending(c => c.GetParameters().Length)
.FirstOrDefault();
if (constructorMethod == null)
{
throw new Exception("无法获取有效的上下文构造器");
}
var dbContextOptionsBuilderType = typeof(DbContextOptionsBuilder<>);
var dbContextOptionsType = typeof(DbContextOptions);
var dbContextOptionsGenericType = typeof(DbContextOptions<>);
var serviceProviderType = typeof(IServiceProvider);
var getServiceMethod = serviceProviderType.GetMethod("GetService");
var lambdaParameterExpressions = new ParameterExpression[2];
lambdaParameterExpressions[0] = (Expression.Parameter(serviceProviderType, "serviceProvider"));
lambdaParameterExpressions[1] = (Expression.Parameter(dbContextOptionsType, "dbContextOptions"));
var paramTypes = constructorMethod.GetParameters();
var argumentExpressions = new Expression[paramTypes.Length];
for (int i = 0; i < paramTypes.Length; i++)
{
var pType = paramTypes[i];
if (pType.ParameterType == dbContextOptionsType ||
(pType.ParameterType.IsGenericType && pType.ParameterType.GetGenericTypeDefinition() == dbContextOptionsGenericType))
{
argumentExpressions[i] = Expression.Convert(lambdaParameterExpressions[1], pType.ParameterType);
}
else if (pType.ParameterType == serviceProviderType)
{
argumentExpressions[i] = lambdaParameterExpressions[0];
}
else
{
argumentExpressions[i] = Expression.Call(lambdaParameterExpressions[0], getServiceMethod);
}
}
factory = Expression
.Lambda>(
Expression.Convert(Expression.New(constructorMethod, argumentExpressions), typeof(DbContext)), lambdaParameterExpressions.AsEnumerable())
.Compile();
_expressionFactoryDict.TryAdd(dbContextType, factory);
dbContext = factory(_serviceProvider, dbContextOptions);
}
var unitOfWorkFactory = _serviceProvider.GetRequiredService();
unitOfWork = unitOfWorkFactory.GetUnitOfWork(_serviceProvider, dbContext);
_works.TryAdd(key, unitOfWork);
return unitOfWork;
}
}
public void Dispose()
{
if (_works != null && _works.Count > 0)
{
foreach (var unitOfWork in _works.Values)
unitOfWork.Dispose();
_works.Clear();
}
}
}
public static class DbProviderExtensions
{
public static IUnitOfWork GetUnitOfWork(this IDbProvider provider, string dbName = null)
{
if (provider == null)
return null;
return provider.GetUnitOfWork(typeof(TDbContext), dbName);
}
} ///
/// 业务系统配置选项
///
public class FxOptions
{
public FxOptions()
{
}
///
/// 默认数据库类型
///
public DatabaseType DefaultDatabaseType { get; set; } = DatabaseType.SqlServer;
///
/// 数据库连接配置
///
public IDictionary DbConnections { get; set; }
}
public class FxOptionsSetup: IConfigureOptions
{
private readonly IConfiguration _configuration;
public FxOptionsSetup(IConfiguration configuration)
{
_configuration = configuration;
}
///
/// 配置options各属性信息
///
///
public void Configure(FxOptions options)
{
SetDbConnectionsOptions(options);
// ...
}
private void SetDbConnectionsOptions(FxOptions options)
{
var dbConnectionMap = new Dictionary();
options.DbConnections = dbConnectionMap;
IConfiguration section = _configuration.GetSection("FxCore:DbConnections");
Dictionary dict = section.Get>();
if (dict == null || dict.Count == 0)
{
string connectionString = _configuration["ConnectionStrings:DefaultDbContext"];
if (connectionString == null)
{
return;
}
dbConnectionMap.Add("DefaultDb", new DbConnectionOptions
{
ConnectionString = connectionString,
DatabaseType = options.DefaultDatabaseType
});
return;
}
var ambiguous = dict.Keys.GroupBy(d => d).FirstOrDefault(d => d.Count() > 1);
if (ambiguous != null)
{
throw new Exception($"数据上下文配置中存在多个配置节点拥有同一个数据库连接名称，存在二义性：{ambiguous.First()}");
}
foreach (var db in dict)
{
dbConnectionMap.Add(db.Key, db.Value);
}
}
}
///
/// DbContextOptionsBuilder配置选项
///
public class DbContextOptionsBuilderOptions
{
///
/// 配置DbContextOptionsBuilder, dbName指定数据库名称, 为null时表示所有数据库,默认为null
///
///
///
///
public DbContextOptionsBuilderOptions(DbContextOptionsBuilder build, string dbName = null, Type dbContextType = null)
{
Builder = build;
DbName = dbName;
DbContextType = dbContextType;
}
public DbContextOptionsBuilder Builder { get; }
public string DbName { get; }
public Type DbContextType { get; }
} FxOptions是业务系统的配置选项(随便取得), 在通过service.GetService
public interface IDbContextOptionsBuilderUser
{
///
/// 获取 数据库类型名称，如 SQLSERVER，MYSQL，SQLITE等
///
DatabaseType Type { get; }
///
/// 使用数据库
///
/// 创建器
/// 连接字符串
/// IDbContextOptionsBuilderUser接口用来适配不同的数据库来源
使用
{
"FxCore": {
"DbConnections": {
"TestDb": {
"ConnectionString": "xxx",
"DatabaseType": "SqlServer"
},
"TestDb_Read": {
"ConnectionString": "xxx",
"DatabaseType": "SqlServer"
}
}
}
} class Program
{
static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var services = new ServiceCollection()
.AddSingleton(config)
.AddOptions()
.AddSingleton, FxOptionsSetup>()
.AddScoped()
.AddSingleton()
.AddSingleton()
.AddSingleton()
.AddSingleton(new DbContextOptionsBuilderOptions(new DbContextOptionsBuilder(), null, typeof(TestDbContext)));
var serviceProvider = services.BuildServiceProvider();
var dbProvider = serviceProvider.GetRequiredService();
var uow = dbProvider.GetUnitOfWork("TestDb"); // 访问主库
var repoDbTest = uow.GetRepository();
var obj = new DbTest { Name = "123", Date = DateTime.Now.Date };
repoDbTest.Insert(obj);
uow.SaveChanges();
Console.ReadKey();
var uow2 = dbProvider.GetUnitOfWork("TestDb_Read");
var uow2 = dbProvider.GetUnitOfWork("TestDb_Read"); // 访问从库
var repoDbTest2 = uow2.GetReadOnlyRepository();
var data2 = repoDbTest2.GetFirstOrDefault();
Console.WriteLine($"id: {data2.Id} name: {data2.Name}");
Console.ReadKey();
}
} 这里直接用控制台来做一个例子,中间多了一个Console.ReadKey()是因为我本地没有配置主从模式,所以实际上我是先插入数据,然后复制到另一个数据库里,再进行读取的.
总结
本文给出的解决方案适用于系统中存在多个不同的上下文,能够适应复杂的业务场景.但对已有代码的侵入性比较大,不知道有没有更好的方案,欢迎一起探讨.