企業項目實戰 .Net Core + Vue/Angular 分庫分表日誌系統六 | 最終篇-經過AOP自動鏈接數據庫-完成日誌業務

public class IocManager
    {
        public static IServiceCollection Services { get; private set; }

        public static IServiceProvider ServiceProvider { get; private set; }

        public static IConfiguration Configuration { get; private set; }

        static IocManager()
        {
            Services = new ServiceCollection();
        }

        public static IServiceProvider Build()
        {
            ServiceProvider = Services.BuildServiceProvider();
            return ServiceProvider;
        }

        public static void SetConfiguration(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public static void SetServiceProvider(IServiceProvider serviceProvider)
        {
            if (ServiceProvider == null) {
                return;
            }
            ServiceProvider = serviceProvider;
        }


    }

對IocManager的參數進行初始化，方便調用Configuration 和調用 ServiceProvider

2.增長AOP 以前說的咱們不能手動去搞數據庫鏈接，那麼這裏我就藉助AOP來作

安裝依賴包

Autofac
Autofac.Extensions.DependencyInjection
Autofac.Extras.DynamicProxy

在 Program 中加入下面這行代碼這是 Autofac在Core 3.0以後的用法

.UseServiceProviderFactory(new AutofacServiceProviderFactory())

在Startup 新建方法 ConfigureContainer Autofac會在啓動的時候默認調用,你們可能對我寫在 ConfigureContainer 方法中的感到好奇，那麼這是什麼呢，
和以前倉儲同樣，SqlSugar 和其餘ORM框架的動態鏈接數據庫代碼不同因此咱們先建立基類進行約束而後各自ORM進行實現，由於這部分屬於業務層代碼，因此我沒有放到 EasyLogger.DbStorage 而是放在啓動程序中

public void ConfigureContainer(ContainerBuilder builder)
        {
            builder.RegisterType<SqlSugarDynamicLink>().As<IDynamicLinkBase>().EnableClassInterceptors();
            builder.RegisterType<SqlSugarDynamicLinkAop>();

        }

至於 SqlSugarDynamicLinkAop 就是咱們的動態鏈接數據庫的AOP方法，下面咱們開始實現他們

首先動態鏈接數據庫的關鍵依據是查詢的時間，咱們的數據庫分庫規則是一個月一個數據庫，一天一張表，那麼咱們就先來定義一個規範的DTO

public class DynamicLinkInput: PagedInput
{
        public DateTime TimeStart { get; set; }

        public DateTime TimeEnd { get; set; }
}

在 AOP 文件夾新建 DynamicLinkAopBase 接口約束ORM的鏈接

public abstract class DynamicLinkAopBase : IInterceptor
    {
        /// <summary>
        ///  AOP的攔截方法
        /// </summary>
        /// <param name="invocation"></param>
        public abstract void Intercept(IInvocation invocation);

        /// <summary>
        /// 獲取查詢所需的必要條件
        /// </summary>
        /// <param name="invocation"></param>
        /// <returns></returns>
        public DynamicLinkInput GetTiemRange(IInvocation invocation) {
            var methodArguments = invocation.Arguments.FirstOrDefault();//獲取參數列表
            var input = (DynamicLinkInput)methodArguments;
            return input;
        }

        public DynamicLinkAttribute GetDynamicLinkAttributeOrNull(MethodInfo methodInfo) {

            var attrs = methodInfo.GetCustomAttributes(true).OfType<DynamicLinkAttribute>().ToArray();
            if(attrs.Length > 0) {
                return attrs[0];
            }
            attrs = methodInfo.DeclaringType.GetTypeInfo().GetCustomAttributes(true).OfType<DynamicLinkAttribute>().ToArray();
            if (attrs.Length > 0)
            {
                return attrs[0];
            }
            return null;
        }



    }

在 AOP 文件夾新建 DynamicLinkAttribute 註解

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
public class DynamicLinkAttribute: Attribute
{
        public bool IsDisabled { get; set; }
}

實現 SqlSugar 的動態鏈接 SqlSugarDynamicLinkAop 那麼這個AOP幹了啥呢

1.我判斷這個類是否進行動態數據庫鏈接

2.我獲取到必要的開始結束時間，來獲取以前產生了多少個月份

3.把這些月份動態的加入到鏈接提供程序存儲器。

public class SqlSugarDynamicLinkAop : DynamicLinkAopBase
    {
        private readonly IServiceProvider _serviceProvider;


        public override void Intercept(IInvocation invocation)
        {
            MethodInfo method;
            try
            {
                method = invocation.MethodInvocationTarget;
            }
            catch (Exception ex)
            {

                method = invocation.GetConcreteMethod();
            }


            var dynamicLinkAttr = GetDynamicLinkAttributeOrNull(method);
            if (dynamicLinkAttr == null || dynamicLinkAttr.IsDisabled)
            {
                invocation.Proceed();//直接執行被攔截方法
            }
            else
            {

                var input = this.GetTiemRange(invocation);

                var dateList = TimeTools.GetMonthByList(input.TimeStart.ToString("yyyy-MM"), input.TimeEnd.ToString("yyyy-MM"));

                foreach (var item in dateList)
                {
                    var DbName = $"{IocManager.Configuration["EasyLogger:DbName"]}-{item.ToString("yyyy-MM")}";
                    var dbPathName = Path.Combine(PathExtenstions.GetApplicationCurrentPath(), DbName + ".db");

                    IocManager.ServiceProvider.AddSqlSugarDatabaseProvider(new SqlSugarSetting()
                    {
                        Name = DbName,
                        ConnectionString = @$"Data Source={dbPathName}",
                        DatabaseType = DbType.Sqlite,
                        LogExecuting = (sql, pars) =>
                        {
                            Console.WriteLine($"sql:{sql}");
                        }
                    });

                }


                invocation.Proceed();//直接執行被攔截方法
            }


        }
    }

這裏用的 AddSqlSugarDatabaseProvider 以前沒有寫其實若是看懂了，以前的說明，這裏怎麼寫你們都能寫出來,就是獲取到鏈接提供程序存儲器往裏面加入了一個鏈接。

public static IServiceProvider AddSqlSugarDatabaseProvider(this IServiceProvider serviceProvider, ISqlSugarSetting dbSetting)
        {
            if (dbSetting == null)
            {
                throw new ArgumentNullException(nameof(dbSetting));
            }

            var fSqlProviderStorage = serviceProvider.GetRequiredService<ISqlSugarProviderStorage>();

            fSqlProviderStorage.AddOrUpdate(dbSetting.Name, new SqlSugarProvider(dbSetting));

            return serviceProvider;
        }

那麼這個AOP 怎麼用呢，新建接口 IDynamicLinkBase 來提供 AOP調用實現類是
SqlSugarDynamicLink (這裏直接用類也能夠我只是我的習慣)

基本上到此爲止，你們已經看明白路線了

1.咱們調用約束的Dto 傳遞開始、結束時間
2.AOP攔截到咱們條件，判斷方法是否須要動態注入鏈接
3.根據開始結束時間把範圍內的數據庫都鏈接上，其中咱們作了一個最大開始時間和最大結束時間的判斷，防止數據庫沒有出現鏈接錯誤

業務測驗邏輯

老規矩新建 EasyLoggerRecordDto文件夾存儲Dto

public class CreateOrUpdateEasyLoggerRecordInput
    {
        public EasyLoggerRecordEditDto EasyLoggerRecord { get; set; }
    }

     public class EasyLoggerRecordEditDto
    {
        public int? Id { get; set; }
        /// <summary>
        /// 項目Id
        /// </summary>
        public int ProjectId { get; set; }
        /// <summary>
        /// 類型.自定義標籤
        /// </summary>
        public string LogType { get; set; }
        /// <summary>
        /// 狀態-成功、失敗、警告等
        /// </summary>
        public string LogState { get; set; }
        /// <summary>
        /// 標題
        /// </summary>
        public string LogTitle { get; set; }
        /// <summary>
        /// 內容描述
        /// </summary>
        public string LogContent { get; set; }
        /// <summary>
        /// 在系統中產生的時間
        /// </summary>
        public DateTime LogTime { get; set; }
    }


     public class EasyLoggerRecordInput : DynamicLinkInput
    {
        /// <summary>
        /// 項目Id
        /// </summary>
        public int? ProjectId { get; set; }
        /// <summary>
        /// 類型.自定義標籤
        /// </summary>
        public string LogType { get; set; }
        /// <summary>
        /// 狀態-成功、失敗、警告等
        /// </summary>
        public string LogState { get; set; }
        /// <summary>
        /// 標題
        /// </summary>
        public string LogTitle { get; set; }
    }

     public class EasyLoggerRecordListDto
    {
        public int Id { get; set; }
        /// <summary>
        /// 項目Id
        /// </summary>
        public int ProjectId { get; set; }
        /// <summary>
        /// 類型.自定義標籤
        /// </summary>
        public string LogType { get; set; }
        /// <summary>
        /// 狀態-成功、失敗、警告等
        /// </summary>
        public string LogState { get; set; }
        /// <summary>
        /// 標題
        /// </summary>
        public string LogTitle { get; set; }
        /// <summary>
        /// 內容描述
        /// </summary>
        public string LogContent { get; set; }
        /// <summary>
        /// 在系統中產生的時間
        /// </summary>
        public DateTime LogTime { get; set; }

        public EasyLoggerProjectEditDto EasyLoggerProject { get; set; }
        /// <summary>
        /// 建立時間
        /// </summary>
        public DateTime CreateTime { get; set; }
    }

新建 LoggerController 注入所需依賴

這裏我就先貼一張圖你們來看看整個流程怎麼玩的思考一下

1.首先執行AOP 而且拿到注入了那些鏈接

2.從默認庫中獲取咱們的項目信息存儲到內存

3.咱們經過獲得的注入鏈接，來進行日誌的查詢

4.咱們關聯上每一個日誌所屬的項目返回結果

咱們在來細看摺疊部分的邏輯

1.Item是一個庫咱們拿到這個庫全部的天數表

2.使用 ChangeProvider 來切換數據庫鏈接鏈接到 Item這個時間點的數據庫

3.經過SqlSugar提供的方法進行 UnionAll

4.查詢數據加入返回列表中

[HttpPost("GetEasyLoggerAsync")]
        [DynamicLink]
        public async Task<PagedResultDto<EasyLoggerRecordListDto>> GetEasyLoggerAsync(EasyLoggerRecordInput input) {
            // 獲取查詢的時間範圍
            var dateList = _linkBase.DynamicLinkOrm(input).OrderByDescending(s => s).ToList();
            var result = new PagedResultDto<EasyLoggerRecordListDto>();
            // 查詢初始數據庫數據
            var projectList = _sqlRepository.GetCurrentSqlSugar().Queryable<EasyLoggerProject>().ToList();
            var DbName = IocManager.Configuration["EasyLogger:DbName"];
            var entityList = new List<EasyLoggerRecord>();
            // 爲跨庫查詢定義的參數
            int Sumtotal = 0;
            foreach (var item in dateList)
            {


                var dayList = TimeTools.GetDayDiff(item.AddDays(1 - DateTime.Now.Day).Date, item.AddDays(1 - DateTime.Now.Day).Date.AddMonths(1).AddSeconds(-1));
                using (_sqlRepository.ChangeProvider($"{DbName}-" + item.ToString("yyyy-MM")))
                {
                    var sqlSugarClient = _sqlRepository.GetCurrentSqlSugar();
                    var queryables = new List<ISugarQueryable<EasyLoggerRecord>>();
                    _sqlRepository.GetCurrentSqlSugar().Queryable<EasyLoggerRecord>();
                    foreach (var day in dayList)
                    {
                        queryables.Add(sqlSugarClient.Queryable<EasyLoggerRecord>().AS($"EasyLoggerRecord_{day}"));
                    }
                    var sqlSugarLogger = sqlSugarClient.UnionAll(queryables);
                    var data = sqlSugarLogger
                         .Where(s => s.CreateTime >= input.TimeStart)
                         .Where(s => s.CreateTime <= input.TimeEnd)
                         .WhereIF(!string.IsNullOrWhiteSpace(input.LogTitle), s => s.LogTitle == input.LogTitle)
                         .WhereIF(!string.IsNullOrWhiteSpace(input.LogType), s => s.LogType == input.LogType)
                         .WhereIF(input.ProjectId != null, s => s.ProjectId == input.ProjectId)
                         .WhereIF(input.LogState != null, s => s.LogState == input.LogState)
                         .OrderBy(s => s.CreateTime, OrderByType.Desc)
                         .ToPageList(input.PageIndex, input.PageSize, ref Sumtotal);
                    entityList.AddRange(data);
                }
            }
            result.Total = Sumtotal;
            result.List = _mapper.Map<List<EasyLoggerRecordListDto>>(entityList);
            foreach (var item in result.List)
            {
                var project = projectList.Where(s => s.Id == item.ProjectId).FirstOrDefault();
                item.EasyLoggerProject = _mapper.Map<EasyLoggerProjectEditDto>(project);
            }
            return result;
        }