【.Net7-性能优化篇】.Net7+WebApi+EFCore+SqlServer读写分离封装

namespace MengLin.Shopping.SchoolDB.DbFirst.ConfigureOptions
{
    /// <summary>
    /// 数据库连接配置
    /// </summary>
    public class ConnectionStringOptions
    {
        /// <summary>
        /// 写链接-主库Mast
        /// </summary>
        public string WriteConnection
        {
            get;
            set;
        }

        /// <summary>
        /// 读链接-从库Salve
        /// </summary>
        public List<string> ReadConnectionList
        {
            get;
            set;
        }
    }
}

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStringOptions": {
    "WriteConnection": "Server=meng\\MSSQLSERVERML;Database=SchoolDB;uid=sa;pwd=123456abc;Trusted_Connection=True;TrustServerCertificate=true",
    "ReadConnectionList": [
      "Server=meng\\MSSQLSERVERML;Database=SchoolDB_Read_1;uid=sa;pwd=123456abc;Trusted_Connection=True;TrustServerCertificate=true",
      "Server=meng\\MSSQLSERVERML;Database=SchoolDB_Read_2;uid=sa;pwd=123456abc;Trusted_Connection=True;TrustServerCertificate=true"
    ]
  }
}

namespace MengLin.Shopping.SchoolDB.DbFirst.Enum
{
    public enum WriteAndReadEnum
    {
        //主库操作
        Write,
        //从库操作
        Read
    }
}

    /// <summary>
    /// 基本操作接口
    /// </summary>
    public interface IBaseService
    {
        /// <summary>
        /// 添加数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        T Insert<T>(T t) where T : class;

        /// <summary>
        /// 根据表达式目录树进行分页查找数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expression">表达式目录树</param>
        /// <param name="writeAndReadEnum">默认从库操作</param>
        /// <returns></returns>
        (IQueryable<T>, int totalCount) Where<T>(Expression<Func<T, bool>> expression,int pageIndex,int pageSize, WriteAndReadEnum writeAndReadEnum = WriteAndReadEnum.Read) where T : class;

        /// <summary>
        /// 保存提交
        /// </summary>
        void Commit();
    }

　　 /// <summary>
    /// 基本操作实现
    /// </summary>
    public class BaseService : IBaseService, IDisposable
    {
        /// <summary>
        /// 数据访问工厂
        /// </summary>
        private DBContextFactory _dbContextFactory = null;

        /// <summary>
        /// 构造函数注入DbContext工厂
        /// </summary>
        /// <param name="dbContext"></param>
        public BaseService(DBContextFactory dbContextFactory)
        {
            _dbContextFactory = dbContextFactory;
        }

        /// <summary>
        /// 插入数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">主键</param>
        /// <returns></returns>
        public T Insert<T>(T t) where T : class
        {
            //只能对主库增加
            _dbContext = _dbContextFactory.GetSetupDbContext(WriteAndReadEnum.Write);

            _dbContext.Set<T>().Add(t);
            return t;
        }

        /// <summary>
        /// 保存提交
        /// </summary>
        public void Commit()
        {
            _dbContext.SaveChanges();
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            if (_dbContext != null)
            {
                _dbContext.Dispose();
            }
        }

        /// <summary>
        /// 根据表达式目录树进行分页查找数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expression">表达式目录树</param>
        /// <param name="writeAndReadEnum">默认从库操作</param>
        /// <returns></returns>
        public (IQueryable<T>,int totalCount) Where<T>(Expression<Func<T, bool>> expression, int pageIndex, int pageSize, WriteAndReadEnum writeAndReadEnum = WriteAndReadEnum.Read) where T : class
        {
            //选择其中一个从库进行查询
            _dbContext = _dbContextFactory.GetSetupDbContext(writeAndReadEnum);

            return (_dbContext.Set<T>().Where(expression).Skip((pageIndex-1) * pageSize).Take(pageSize), _dbContext.Set<T>().Where(expression).Count());
        }
    }

　　 /// <summary>
    /// 学生接口
    /// </summary>
    public interface IStudentService:IBaseService
    {
        /// <summary>
        /// 学习
        /// </summary>
        public void Study();


        /// <summary>
        /// 玩游戏
        /// </summary>
        public void PalyGame();
    }

    /// <summary>
    /// 学生服务
    /// </summary>
    public class StudentService:BaseService, IStudentService
    {

        public StudentService(DBContextFactory dbContextFactory) : base(dbContextFactory)
        {

        }

        /// <summary>
        /// 学习
        /// </summary>
        public void Study()
        {
            Console.WriteLine("我要学习了！");
        }


        /// <summary>
        /// 玩游戏
        /// </summary>
        public void PalyGame()
        {
            Console.WriteLine("我要玩游戏了！");
        }
    }

namespace MengLin.Shopping.SchoolDB.DbFirst.Factory
{
    /// <summary>
    /// DBContext制造工厂
    /// </summary>
    public class DBContextFactory
    {
        /// <summary>
        /// DbContext数据库上下文
        /// </summary>
        private readonly DbContext _dbContext = null;

        /// <summary>
        /// 读/写数据库连接字符串配置
        /// </summary>
        private readonly ConnectionStringOptions _connectionStringOptions = null;

        /// <summary>
        /// 构造函数注入DbContext实例
        /// 构造函数Option注入读/写数据库连接字符串配置
        /// </summary>
        /// <param name="dbContext"></param>
        public DBContextFactory(DbContext dbContext, IOptionsSnapshot<ConnectionStringOptions> connectionStringOptions)
        {
            _dbContext = dbContext;
            _connectionStringOptions = connectionStringOptions.Value;
        }

        /// <summary>
        /// 得到已经重新设置过数据库连接的DbContext
        /// </summary>
        /// <param name="writeAndReadEnum">标记读或写</param>
        /// <returns></returns>
        public DbContext GetSetupDbContext(WriteAndReadEnum writeAndReadEnum)
        {
            //设置读数据库连接字符串
            if (writeAndReadEnum is WriteAndReadEnum.Read)
            {
                SetReadConnectionString();
            }
            else if(writeAndReadEnum is WriteAndReadEnum.Write)//设置写数据库连接字符串
            {
                SetWriteConnectionString();
            }

            return _dbContext;
        }

        /// <summary>
        /// 设置写数据库连接字符串
        /// </summary>
        private void SetWriteConnectionString()
        {
            //从注入的Options配置中获取写的数据库链接字符串
            string writeConnectionString = _connectionStringOptions.WriteConnection;

            if (_dbContext is SchoolDBContext)
            {
                var schoolDBContext = (SchoolDBContext)_dbContext; 

                schoolDBContext.SetWriteOrReadConnectionString(writeConnectionString);
            }
        }

        private static int seed = 0;//种子
        /// <summary>
        /// 设置读数据库连接字符串
        /// </summary>
        private void SetReadConnectionString()
        {//随机策略--取得读的数据库链接字符串
            //int connectionStringCount = _connectionStringsOptions.ReadConnectionList.Count;
            //int index = new Random().Next(0, connectionStringCount);
            //string readConnectionString = _connectionStringsOptions.ReadConnectionList[index];

            //均衡策略---第1次index为0，第2次index为1，第3次index为0
            //          第4次index为1，第5次index为0，第6次index为1
            //          第7次index为0，第8次index为1，第9次index为0
            //          0 % 2 = 0      1 % 2 = 1      2 % 2 = 0
            //          3 % 2 = 1      4 % 2 = 0      5 % 2 = 1
            //          6 % 2 = 0      7 % 2 = 1      8 % 2 = 0
            int connectionStringCount = _connectionStringOptions.ReadConnectionList.Count;
            int index = seed++ % connectionStringCount;
            string readConnectionString = _connectionStringOptions.ReadConnectionList[index];//索引不是0就是1

            if (_dbContext is SchoolDBContext)
            {
                var schoolDBContext = (SchoolDBContext)_dbContext; 
                schoolDBContext.SetWriteOrReadConnectionString(readConnectionString);
            }
        }
    }
}

　　　　protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
       {
            if (!optionsBuilder.IsConfigured)
            {
                //这里写死了
                //optionsBuilder.UseSqlServer("Server=meng\\MSSQLSERVERML;Database=SchoolDB;uid=sa;pwd=123456abc;Trusted_Connection=True;TrustServerCertificate=true");

                //动态使用数据库链接字符串
                optionsBuilder.UseSqlServer(connectionString);
            }
        }


        //数据库链接字符串
        private string connectionString = string.Empty;

        /// <summary>
        /// 设置读或者写的数据库链接字符串
        /// </summary>
        /// <param name="connString">链接字符串</param>
        public void SetWriteOrReadConnectionString(string connString)
        {
            connectionString = connString;
        }

    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            // Add services to the container.

            builder.Services.AddControllers();
            // Learn more about configuring Swagger/OpenAPI at http://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();

            #region 注册服务，以及数据库上下文工厂
            {
                //注册数据库上下文类
                builder.Services.AddScoped<DbContext, SchoolDBContext>();
                //注注册数据库上下文工厂类-目的：为了修改数据库上下文类的数据库连接字符串
                builder.Services.AddScoped<DBContextFactory, DBContextFactory>();
                //注册学生服务
                builder.Services.AddScoped<IStudentService, StudentService>();
            }
            #endregion

            #region 注册配置
            {
                //注册配置实例到哪个TOptions
                builder.Services.Configure<ConnectionStringOptions>(builder.Configuration.GetSection("ConnectionStringOptions"));
            }
            #endregion

            //添加跨越策略
            builder.Services.AddCors(options => options.AddPolicy("any", policy =>
            {
                //设定允许跨域的来源，有多个可以用','隔开
                policy.WithOrigins("http://localhost:8080", "http://localhost:8080")
                .AllowAnyHeader()//允许任何标头
                .AllowAnyMethod()//允许任何方法访问
                .AllowCredentials();//允许凭据的策略
            }));


            builder.Services.AddSwaggerGen(s =>
            {
                s.SwaggerDoc("V1", new OpenApiInfo()
                {
                    Title = "通用后台系统",
                    Version = "Version-01",
                    Description = "通用后台系统"
                });
                var currentDirectory = AppContext.BaseDirectory;
                s.IncludeXmlComments($"{currentDirectory}/MengLin.DotNet7.WebAPI.xml");
            });

            var app = builder.Build();

            // Configure the HTTP request pipeline.
            if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI(s =>
                {
                    s.SwaggerEndpoint("/swagger/V1/swagger.json", "test1");
                });
            }
            //使用跨越策略
            app.UseCors("any");

            app.UseHttpsRedirection();

            app.UseAuthorization();


            app.MapControllers();

            app.Run();
        }
    }

namespace MengLin.DotNet7.WebAPI.Controllers
{
    /// <summary>
    /// 学生
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class StudentsController : ControllerBase
    {
        /// <summary>
        /// 获取学生列表
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("{pageindex}/{pagesize}")]
        public RespResult Get(IStudentService studentService)
        {
            //从请求中获取路由数据
            RouteValueDictionary dicRouteValue = HttpContext.Request.RouteValues;
            //url中的页索引和页大小
            int.TryParse(dicRouteValue["pageindex"]?.ToString(),out int pageIndex);
            int.TryParse(dicRouteValue["pageSize"]?.ToString(), out int pageSize);

            var respResult = new RespResult<IQueryable<Student>>();
            //查询满足条件的学生，且带分页
            (IQueryable<Student> studentList,int totalCount) = studentService.Where<Student>(c => c.Sex == "女", pageIndex, pageSize);

            respResult.data = studentList;//结果集
            respResult.TotalCount = totalCount;//记录总条数

            return respResult;
        }
    }
}