EntityFramework Core进行读写分离最佳实践方式，了解一下（二）？

前言

写过上一篇关于EF Core中读写分离最佳实践方式后，虽然在必定程度上改善了问题，可是在评论中有的指出更换到从数据库，那么接下来要进行插入此时又要切换到主数据库，同时有的指出是否能够进行底层无感知操做，这确实是个问题，本文继续进行引路，进一步改善评论中问题的指出，至于实现更复杂的逻辑可自行实现，感谢大家很是棒的评论，使得本文由此而生。

EF Core读写分离进一步完善

如评论前辈们指出在EF 6.x中咱们知道有IDbCommandInterceptor接口，咱们可对执行的SQL语句进行拦截，从而可自定义实现咱们想要的需求，虽然在EF Core中却没有拦截器特性的实现，可是针对此特性的实现DiagnosticSource记录跟踪类来实现等效于拦截器的实现，当前DiagnosticSource使用文档还没有完善，估计还得等待一段时间，接下来咱们来看看如何实现。在DiagnosticSource包中有DiagnosticListener类，咱们经过此类来跟踪记录，若是执行的EF Core包，那么咱们将利用DiagnosticListener进行订阅，订阅到以后咱们拿到跟踪命令，从而实现无感知更换数据库，代码以下：

    public class DbCommandInterceptor : IObserver<KeyValuePair<string, object>>
    {
        private const string masterConnectionString = "data source=WANGPENG;User Id=sa;Pwd=sa123;initial catalog=Demo1;integrated security=True;";
        private const string slaveConnectionString = "data source=WANGPENG;User Id=sa;Pwd=sa123;initial catalog=Demo2;integrated security=True;";
        public void OnCompleted()
        {
        }

        public void OnError(Exception error)
        {
        }

        public void OnNext(KeyValuePair<string, object> value)
        {
            if (value.Key == RelationalEventId.CommandExecuting.Name)
            {
                var command = ((CommandEventData)value.Value).Command;
                var executeMethod = ((CommandEventData)value.Value).ExecuteMethod;

                if (executeMethod == DbCommandMethod.ExecuteNonQuery)
                {
                    ResetConnection(command, masterConnectionString);
                }
                else if (executeMethod == DbCommandMethod.ExecuteScalar)
                {
                    ResetConnection(command, slaveConnectionString);
                }
                else if (executeMethod == DbCommandMethod.ExecuteReader)
                {
                    ResetConnection(command, slaveConnectionString);
                }
            }
        }

        void ResetConnection(DbCommand command, string connectionString)
        {
            if (command.Connection.State == ConnectionState.Open)
            {
                if (!command.CommandText.Contains("@@ROWCOUNT"))
                {
                    command.Connection.Close();
                    command.Connection.ConnectionString = connectionString;
                }
            }
            if (command.Connection.State == ConnectionState.Closed)
            {
                command.Connection.Open();
            }
        }
    }

这里存在一个问题，上述 command.CommandText.Contains("@@ROWCOUNT") 代码，由于在进行添加操做时，会返回主键，那么此时会进行查询，因此暂时没有更好的方式是确认主-从数据库。

    public class CommandListener : IObserver<DiagnosticListener>
    {
        private readonly DbCommandInterceptor _dbCommandInterceptor = new DbCommandInterceptor();

        public void OnCompleted()
        {
        }

        public void OnError(Exception error)
        {
        }

        public void OnNext(DiagnosticListener listener)
        { 
            if (listener.Name == DbLoggerCategory.Name)
            {
                listener.Subscribe(_dbCommandInterceptor);
            }
        }
    }

上述 DbLoggerCategory.Name 也就是 Microsoft.EntityFrameworkCore ，经过监控的包是Microsoft.EntityFrameworkCore，则进行订阅，最后咱们在startup中进行注册该监听类。

 DiagnosticListener.AllListeners.Subscribe(new CommandListener());

接下来咱们经过动态图来看看最终实际效果，主-从复制依然是经过SQL Server发布-订阅的方式来同步数据。在控制器中，咱们只利用demo1上下文来添加和查询数据，当查询时更换到从数据库，此时已经是无感知（请见上一篇），以下：

        [HttpGet("index")]
        public IActionResult Index()
        {
            var blogs = _demo1DbContext.Blogs.ToList();
            return View(blogs);
        }

        [HttpGet("create")]
        public IActionResult CreateDemo1Blog()
        {
            var blog = new Blog()
            {
                Name = "demoBlog1",
                Url = "http://www.cnblogs.com/createmyslef"
            };
            _demo1DbContext.Blogs.Add(blog);
            _demo1DbContext.SaveChanges();
            return RedirectToAction(nameof(Index));
        }

 

总结

本文只是在上一篇的基础上进一步改善了读写分离的操做，得益于github上有提出可经过跟踪记录来解决，经过跟踪记录从底层出发来完善读写分离操做，咱们可拿到底层实现的命令以及其余和EF 6.x中利用拦截器等效，至于更加复杂的逻辑可自行实现。