概念相关

    为了确保多线上环境数据库的稳定性和可用性，大部分情况下都使用了双机热备的技术。一般是一个主库+一个从库或者多个从库的结构，从库的数据来自于主库的同步。在此基础上我们可以通过数据库反向代理工具或者使用程序的方式实现读写分离，即主库接受事务性操作比如删除、修改、新增等操作，从库接受读操作。笔者自认为读写分离解决的痛点是，数据库读写负载非常高的情况下，单点数据库存在读写冲突，从而导致数据库压力过大，出现读写操作缓慢甚至出现死锁或者拒绝服务的情况。它适用与读大于写，并可以容忍一段时间内不一致的情况，因为主从同步存在一定的延迟，大致的实现架构图如下(图片来自于网络)。
    

    虽然我们可以通过数据库代理实现读写分离，比如mycat，这类方案的优势就是对程序本身没有入侵，通过代理本身来拦截sql语句分发到具体数据。甚至是更好的解决方案NewSQL去解决，比如TiDB。但是还是那个原则，无论使用数据库代理或者NewSQL的情况都是比较重型的解决方案，会增加服务节点和运维成本，有时候还没到使用这些终极解决方案的地步，这时候我们会在程序中处理读写分离，所以有个好的思路去在程序中解决读写分离也尤为重要。

基本结构

接下来我们新建三个类，当然这个并不固定，可以根据自己的情况新建类。首先我们新建一个ConnectionStringConsts用来存放连接字符串常量，也就是用来存放读取自配置文件或者配置中心的字符串，这里我直接写死，当然你也可以存放多个连接字符串，大致实现如下。

public class ConnectionStringConsts
{
    /// <summary>
    /// 主库连接字符串
    /// </summary>
    public static readonly string MasterConnectionString = "server=db.master.com;Database=crm_db;UID=root;PWD=1";


    /// <summary>
    /// 从库连接字符串
    /// </summary>
    public static readonly string SlaveConnectionString = "server=db.slave.com;Database=crm_db;UID=root;PWD=1";
}

然后新建存储数据库连接字符串主从映射关系的映射类ConnectionStringMapper，这个类的主要功能就是通过连接字符串建立主库和从库的关系，并且根据映射规则返回实际要操作的字符串，大致实现如下

public static class ConnectionStringMapper
{
    //存放字符串主从关系
    private static readonly IDictionary<string, string[]> _mapper = new Dictionary<string, string[]>();
    private static readonly Random _random = new Random();


    static ConnectionStringMapper()
    {
        //添加数关系映射
        _mapper.Add(ConnectionStringConsts.MasterConnectionString, new[] { ConnectionStringConsts.SlaveConnectionString });
    }


    /// <summary>
    /// 获取连接字符串
    /// </summary>
    /// <param name="masterConnectionStr">主库连接字符串</param>
    /// <param name="useMaster">是否选择读主库</param>
    /// <returns></returns>
    public static string GetConnectionString(string masterConnectionStr,bool useMaster)
    {
        //是否走主库
        if (useMaster)
        {
            return masterConnectionStr;
        }


        if (!_mapper.Keys.Contains(masterConnectionStr))
        {
            throw new KeyNotFoundException("不存在的连接字符串");
        }


        //根据主库获取从库连接字符串
        string[] slaveStrs = _mapper[masterConnectionStr];
        if (slaveStrs.Length == 1)
        {
            return slaveStrs[0];
        }
        return slaveStrs[_random.Next(0, slaveStrs.Length - 1)];
    }
}

这个类是比较核心的操作，关于实现读写分离的核心逻辑都在这，当然你可以根据自己的具体业务实现类似的操作。接下来，我们将封装一个DapperHelper的操作，虽然Dapper用起来比较简单方便，但是依然强烈建议！！！封装一个Dapper操作类，这样的话可以统一处理数据库相关的操作，对于以后的维护修改都非常方便，扩展性的时候也会相对容易一些

public static class DapperHelper
{
    public static IDbConnection GetConnection(string connectionStr)
    {
        return new MySqlConnection(connectionStr);
    }


    /// <summary>
    /// 执行查询相关操作
    /// </summary>
    /// <param name="sql">sql语句</param>
    /// <param name="param">参数</param>
    /// <param name="useMaster">是否去读主库</param>
    /// <returns></returns>
    public static IEnumerable<T> Query<T>(string sql, object param = null, bool useMaster=false)
    {
        //根据实际情况选择需要读取数据库的字符串
        string connectionStr = ConnectionStringMapper.GetConnectionString(ConnectionStringConsts.MasterConnectionString, useMaster);
        using (var connection = GetConnection(connectionStr))
        {
            return connection.Query<T>(sql, param);
        }
    }


    /// <summary>
    /// 执行查询相关操作
    /// </summary>
    /// <param name="connectionStr">连接字符串</param>
    /// <param name="sql">sql语句</param>
    /// <param name="param">参数</param>
    /// <param name="useMaster">是否去读主库</param>
    /// <returns></returns>
    public static IEnumerable<T> Query<T>(string connectionStr, string sql, object param = null, bool useMaster = false)
    {
        //根据实际情况选择需要读取数据库的字符串
        connectionStr = ConnectionStringMapper.GetConnectionString(connectionStr, useMaster);
        using (var connection = GetConnection(connectionStr))
        {
            return connection.Query<T>(sql, param);
        }
    }


    /// <summary>
    /// 执行事务相关操作
    /// </summary>
    /// <param name="sql">sql语句</param>
    /// <param name="param">参数</param>
    /// <returns></returns>
    public static int Execute(string sql, object param = null)
    {
        return Execute(ConnectionStringConsts.MasterConnectionString, sql, param);
    }


    /// <summary>
    /// 执行事务相关操作
    /// </summary>
    /// <param name="connectionStr">连接字符串</param>
    /// <param name="sql">sql语句</param>
    /// <param name="param">参数</param>
    /// <returns></returns>
    public static int Execute(string connectionStr,string sql,object param=null)
    {
        using (var connection = GetConnection(connectionStr))
        {
            return connection.Execute(sql,param);
        }
    }


    /// <summary>
    /// 事务封装
    /// </summary>
    /// <param name="func">操作</param>
    /// <returns></returns>
    public static bool ExecuteTransaction(Func<IDbConnection, IDbTransaction, int> func)
    {
        return ExecuteTransaction(ConnectionStringConsts.MasterConnectionString, func);
    }


    /// <summary>
    /// 事务封装
    /// </summary>
    /// <param name="connectionStr">连接字符串</param>
    /// <param name="func">操作</param>
    /// <returns></returns>
    public static bool ExecuteTransaction(string connectionStr, Func<IDbConnection, IDbTransaction, int> func)
    {
        using (var conn = GetConnection(connectionStr))
        {
            IDbTransaction trans = conn.BeginTransaction();
            return func(conn, trans)>0;
        }
    }
}

首先和大家说一句非常抱歉的话，这个类我是随手封装的，并没有实验是否可用，因为我自己的电脑并没有安装数据库这套环境，但是绝对是可以体现我要讲解的思路，希望大家多多见谅。
    在这里可以看出来Query查询方法中我们传递了一个缺省参数useMaster默认值是false，主要的原因是，很多时候我们可能不能完全的使用事务性操作走主库，读取操作走从库的情况，也就是我们有些场景可能要选择性读主库，这时候我们可以通过这个参数去控制。当然这个字段具体的含义根据你的具体业务实际情况而定，其主要原则就是让更多的操作能命中缺省的情况，比如你大部分读操作都需要去主库，那么你可以设置默认值为true，这样的话特殊情况传递false，这样的话会省下许多操作。如果你大部分读操作都是走从库，只有少数场景需要选择性读主库，那么这个参数你可以设置为false。写就没有这种情况，因为无论哪种场景写都是要在主库进行的，除非双主的情况，这也不是我们本次讨论的重点。

使用方式

通过上述方式完成封装之后，我们在具体数据访问层适用的时候可以通过如下方式，如果按照默认的方式查询可以采用如下的方式。在这里关于写的操作我们就不展示了，因为写的情况是固定的

string queryPersonSql = "select id,name from Person where id=@id";
var person = DapperHelper.Query<Person>(queryPersonSql, new { id = 1 }).FirstOrDefault();

如果需要存在特殊情况，查询需要选择主库的话可以不使用缺省参数，我们可以选择给缺省参数传值，比如我要让查询走主库

string queryPersonSql = "select id,name from Person where id=@id";
var person = DapperHelper.Query<Person>(queryPersonSql, new { id = 1 }, true).FirstOrDefault();

当然，我们上面也提到了，缺省值useMaster是true还是false，这个完全可以结合自身的业务决定。如果大部分查询都是走从库的情况下，缺省值可以为false。如果大部分查询情况都是走主库的时候，缺省值可以给true。关于以上所有的相关封装，模式并不固定，这一点可以完全结合自己的实际业务和代码实现，只是希望能多给大家提供一种思路，其他ORM也有自身提供了操作读写分离的具体实现。

总结

    以上就是笔者关于Dapper实现读写分离的一些个人想法，这种方法也适合其他类似Dapper偏原生SQL操作的ORM框架。这种方式还有一个优点就是如果在现有的项目中，需要支持读写分离的时候，这种操作方式可能对原有代码逻辑，入侵不会那么强，如果你前期封装还比较合理的话，那么改动将会非常小。当然这只是笔者的个人的观点，毕竟具体的实践方式还需要结合实际项目和业务。本次我个人希望能得到大家更多关于这方面的想法，如果你有更好的实现方式欢迎评论区多多留言。

????欢迎扫码关注我的公众号????