基於SqlSugar的開發框架循序漸進介紹（6）-- 在基礎類別介面中注入使用者身份資訊介面

在基於SqlSugar的開發框架中，我們設計了一些系統服務層的基礎類別，在基礎類別中會有很多涉及到相關的資料處理操作的，如果需要跟蹤具體是那個使用者進行操作的，那麼就需要獲得當前使用者的身份資訊，包括在Web API的控制器中也是一樣，需要獲得對應的使用者身份資訊，才能進行相關的身份鑑別和處理操作。本篇隨筆介紹基於Principal的使用者身份資訊的儲存和讀取操作，以及在適用於Winform程式中的記憶體快取的處理方式，從而通過在基礎類別介面中注入使用者身份資訊介面方式，獲得當前使用者的詳細身份資訊。

1、使用者身份介面的定義和基礎類別介面注入

為了方便獲取使用者身份的資訊，我們定義一個介面 IApiUserSession 如下所示。

   /// <summary>
    /// API介面授權獲取的使用者身份資訊-介面
    /// </summary>
    public interface IApiUserSession
    {
        /// <summary>
        /// 使用者登入來源渠道，0為網站，1為微信，2為安卓APP，3為蘋果APP   
        /// </summary>
        string Channel { get; }

        /// <summary>
        /// 使用者ID
        /// </summary>
        int? Id { get; }

        /// <summary>
        /// 使用者名稱稱
        /// </summary>
        string Name { get; }

        /// <summary>
        /// 使用者郵箱（可選）   
        /// </summary>
        string Email { get; }

        /// <summary>
        /// 使用者手機（可選）   
        /// </summary>
        string Mobile { get; }

        /// <summary>
        /// 使用者全名稱（可選）   
        /// </summary>
        string FullName { get; }

        /// <summary>
        /// 性別（可選）
        /// </summary>
        string Gender { get; }

        /// <summary>
        /// 所屬公司ID（可選）   
        /// </summary>
        string Company_ID { get; }

        /// <summary>
        /// 所屬公司名稱（可選）   
        /// </summary>
        string CompanyName { get; }

        /// <summary>
        /// 所屬部門ID（可選）   
        /// </summary>
        string Dept_ID { get; }

        /// <summary>
        /// 所屬部門名稱（可選）   
        /// </summary>
        string DeptName { get; }

        /// <summary>
        /// 把使用者資訊設定到快取中去
        /// </summary>
        /// <param name="info">使用者登陸資訊</param>
        /// <param name="channel">預設為空，使用者登入來源渠道：0為網站，1為微信，2為安卓APP，3為蘋果APP </param>
        void SetInfo(LoginUserInfo info, string channel = null);
    }

其中的SetInfo是為了在使用者身份登入確認後，便於將使用者資訊儲存起來的一個介面方法。其他屬性定義使用者相關的資訊。

由於這個使用者身份資訊的介面，我們提供給基礎類別進行使用的，預設我們在基礎類別定義一個介面物件，並通過提供預設的NullApiUserSession實現，便於參照對應的身份屬性資訊。

NullApiUserSession只是提供一個預設的實現，實際在使用的時候，我們會注入一個具體的介面實現來替代它的。

    /// <summary>
    /// 提供一個空白實現類，具體使用IApiUserSession的時候，會使用其他實現類
    /// </summary>
    public class NullApiUserSession : IApiUserSession
    {
        /// <summary>
        /// 單件範例
        /// </summary>
        public static NullApiUserSession Instance { get; } = new NullApiUserSession();

        public string Channel => null;

        public int? Id => null;

        public string Name => null;

        ..................

        /// <summary>
        /// 設定資訊（保留為空）
        /// </summary>
        public void SetInfo(LoginUserInfo info, string channel = null)
        {
        }
    }

在之前介紹的SqlSugar框架的時候，我們介紹到資料存取操作的基礎類別定義，如下所示。

    /// <summary>
    /// 基於SqlSugar的資料庫存取操作的基礎類別物件
    /// </summary>
    /// <typeparam name="TEntity">定義對映的實體類</typeparam>
    /// <typeparam name="TKey">主鍵的型別，如int，string等</typeparam>
    /// <typeparam name="TGetListInput">或者分頁資訊的條件物件</typeparam>
    public abstract class MyCrudService<TEntity, TKey, TGetListInput> : 
        IMyCrudService<TEntity, TKey, TGetListInput>
        where TEntity : class, IEntity<TKey>, new()
        where TGetListInput : IPagedAndSortedResultRequest
    {
        /// <summary>
        /// 資料庫上下文資訊
        /// </summary>
        protected DbContext dbContext;

        /// <summary>
        /// 當前Api使用者資訊
        /// </summary>
        public IApiUserSession CurrentApiUser { get; set; }

        public MyCrudService()
        {
            dbContext = new DbContext();

            CurrentApiUser = NullApiUserSession.Instance;//空實現
        }

在最底層的操作基礎類別中，我們就已經注入了使用者身份資訊，這樣我們不管操作任何函數處理，都可以通過該使用者身份資訊介面CurrentApiUser獲得對應的使用者屬性資訊了。

在具體的業務服務層中，我們繼承該基礎類別，並提供建構函式注入方式，讓基礎類別獲得對應的 IApiUserSession介面的具體範例。

    /// <summary>
    /// 應用層服務介面實現
    /// </summary>
    public class CustomerService : MyCrudService<CustomerInfo, string, CustomerPagedDto>, ICustomerService
    {
        /// <summary>
        /// 建構函式
        /// </summary>
        /// <param name="currentApiUser">當前使用者介面</param>
        public CustomerService(IApiUserSession currentApiUser)
        {
            this.CurrentApiUser = currentApiUser;
        }
          
         ........

    }

如果有其他服務介面需要引入，那麼我們繼續增加其他介面注入即可。

    /// <summary>
    /// 角色資訊 應用層服務介面實現
    /// </summary>
    public class RoleService : MyCrudService<RoleInfo,int, RolePagedDto>, IRoleService
    {
        private IOuService _ouService;
        private IUserService _userService;

        /// <summary>
        /// 預設建構函式
        /// </summary>
        /// <param name="currentApiUser">當前使用者介面</param>
        /// <param name="ouService">機構服務介面</param>
        /// <param name="userService">使用者服務介面</param>
        public RoleService(IApiUserSession currentApiUser, IOuService ouService, IUserService userService)
        {
            this.CurrentApiUser = currentApiUser;
            this._ouService = ouService;
            this._userService = userService;
        }

由於該介面是通過建構函式注入的，因此在系統執行前，我們需要往IOC容器中註冊對應的介面實現類（由於IApiUserSession 提供了多個介面實現，我們這裡不自動加入它的對應介面，而通過手工加入）。

在Winform或者控制檯程式，啟動程式的時候，手工加入對應的介面到IOC容器中即可。

/// <summary>
/// 應用程式的主入口點。
/// </summary>
[STAThread]
static void Main()
{
    // IServiceCollection負責註冊
    IServiceCollection services = new ServiceCollection();
    //services.AddSingleton<IDictDataService, DictDataService>();
    
    //呼叫自定義的服務註冊
    ServiceInjection.ConfigureRepository(services);            
    
    //新增IApiUserSession實現類
    //services.AddSingleton<IApiUserSession, ApiUserCache>(); //快取實現方式
    services.AddSingleton<IApiUserSession, ApiUserPrincipal>(); //CurrentPrincipal實現方式

如果是Web API或者asp.net core專案中加入，也是類似的處理方式。

var builder = WebApplication.CreateBuilder(args);
//設定依賴注入存取資料庫
ServiceInjection.ConfigureRepository(builder.Services);

//新增IApiUserSession實現類
builder.Services.AddSingleton<IApiUserSession, ApiUserPrincipal>();

前面介紹了，IApiUserSession的一個空白實現，是預設的介面實現，我們具體會使用基於Principal或者快取方式實現記錄使用者身份的資訊實現，如下是它們的類關係。

在上面的程式碼中，我們注入一個 ApiUserPrincipal 的使用者身份介面實現。

2、基於Principal的使用者身份資訊的儲存和讀取操作

ApiUserPrincipal 的使用者身份介面實現是可以實現Web及Winform的使用者身份資訊的儲存的。

首先我們先定義一些儲存宣告資訊的鍵，便於統一處理。

    /// <summary>
    /// 定義一些常用的ClaimType儲存鍵
    /// </summary>
    public class ApiUserClaimTypes
    {
        public const string Id = JwtClaimTypes.Id;
        public const string Name = JwtClaimTypes.Name;
        public const string NickName = JwtClaimTypes.NickName;
        public const string Email = JwtClaimTypes.Email;
        public const string PhoneNumber = JwtClaimTypes.PhoneNumber;
        public const string Gender = JwtClaimTypes.Gender;
        public const string FullName = "FullName";
        public const string Company_ID = "Company_ID";
        public const string CompanyName = "CompanyName";
        public const string Dept_ID = "Dept_ID";
        public const string DeptName = "DeptName";

        public const string Role = ClaimTypes.Role;
    }

ApiUserPrincipal 使用者身份介面實現的定義如下程式碼所示。

    /// <summary>
    /// 基於ClaimsPrincipal實現的使用者資訊介面。
    /// </summary>
    [Serializable]
    public class ApiUserPrincipal : IApiUserSession
    {
        /// <summary>
        /// IHttpContextAccessor物件
        /// </summary>
        private readonly IHttpContextAccessor _httpContextAccessor;

        /// <summary>
        /// 如果IHttpContextAccessor.HttpContext?.User非空獲取HttpContext的ClaimsPrincipal，否則獲取執行緒的CurrentPrincipal
        /// </summary>
        protected ClaimsPrincipal Principal => _httpContextAccessor?.HttpContext?.User ?? (Thread.CurrentPrincipal as ClaimsPrincipal);

        /// <summary>
        /// 預設建構函式
        /// </summary>
        /// <param name="httpContextAccessor"></param>
        public ApiUserPrincipal(IHttpContextAccessor httpContextAccessor)
        {
            _httpContextAccessor = httpContextAccessor;
        }

        /// <summary>
        /// 預設建構函式
        /// </summary>
        public ApiUserPrincipal() { }

基於Web API的時候，使用者身份資訊是基於IHttpContextAccessor 注入的介面獲得 httpContextAccessor?.HttpContext?.User 的 ClaimsPrincipal 屬性操作的。

我們獲取使用者身份的屬性的時候，直接通過這個屬性判斷獲取即可。

        /// <summary>
        /// 使用者ID
        /// </summary>
        public int? Id => this.Principal?.FindFirst(ApiUserClaimTypes.Id)?.Value.ToInt32();

        /// <summary>
        /// 使用者名稱稱
        /// </summary>
        public string Name => this.Principal?.FindFirst(ApiUserClaimTypes.Name)?.Value;

而上面同時也提供了一個基於Windows的執行緒Principal 屬性（Thread.CurrentPrincipal ）的宣告操作，操作模型和Web 的一樣的，因此Web和WinForm的操作是一樣的。

在使用者登入介面處理的時候，我們需要統一設定一下使用者對應的宣告資訊，儲存起來供查詢使用。

        /// <summary>
        /// 主要用於Winform寫入Principal的ClaimsIdentity
        /// </summary>
        public void SetInfo(LoginUserInfo info, string channel = null)
        {
            //new WindowsPrincipal(WindowsIdentity.GetCurrent());

            var claimIdentity = new ClaimsIdentity("login");
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.Id, info.ID ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.Name, info.UserName ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.Email, info.Email ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.PhoneNumber, info.MobilePhone ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.Gender, info.Gender ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.FullName, info.FullName ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.Company_ID, info.CompanyId ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.CompanyName, info.CompanyName ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.Dept_ID, info.DeptId ?? ""));
            claimIdentity.AddClaim(new Claim(ApiUserClaimTypes.DeptName, info.DeptName ?? ""));

            //此處不可以使用下面註釋程式碼
            //this.Principal?.AddIdentity(claimIdentity);

            //Thread.CurrentPrincipal設定會導致在非同步執行緒中設定的結果丟失
            //因此統一採用 AppDomain.CurrentDomain.SetThreadPrincipal中設定，確保程序中所有執行緒都會複製到資訊
            IPrincipal principal = new GenericPrincipal(claimIdentity, null);
            AppDomain.CurrentDomain.SetThreadPrincipal(principal);
        }

在上面中，我特別宣告「Thread.CurrentPrincipal設定會導致在非同步執行緒中設定的結果丟失」，這是我在反覆測試中發現，不能在非同步方法中設定Thread.CurrentPrincipal的屬性，否則屬性會丟失，因此主執行緒的Thread.CurrentPrincipal 會賦值替換掉非同步執行緒中的Thread.CurrentPrincipal屬性。

而.net 提供了一個程式域的方式設定CurrentPrincipal的方法，可以或者各個執行緒中統一的資訊。

AppDomain.CurrentDomain.SetThreadPrincipal(principal);

基於WInform的程式，我們在登入介面中處理使用者登入操作

但使用者確認登入的時候，測試使用者的賬號密碼，成功則在本地設定使用者的身份資訊。

        /// <summary>
        /// 統一設定登陸使用者相關的資訊
        /// </summary>
        /// <param name="info">當前使用者資訊</param>
        public async Task SetLoginInfo(LoginResult loginResult)
        {
            var info = loginResult.UserInfo; //使用者資訊

            //獲取使用者的角色集合
            var roles = await BLLFactory<IRoleService>.Instance.GetRolesByUser(info.Id);
            //判斷使用者是否超級管理員||公司管理員
            var isAdmin = roles.Any(r => r.Name == RoleInfo.SuperAdminName || r.Name == RoleInfo.CompanyAdminName);

            //初始化許可權使用者資訊
            Portal.gc.UserInfo = info; //登陸使用者
            Portal.gc.RoleList = roles;//使用者的角色集合
            Portal.gc.IsUserAdmin = isAdmin;//是否超級管理員或公司管理員
            Portal.gc.LoginUserInfo = this.ConvertToLoginUser(info); //轉換為表單可以快取的物件

            //設定身份資訊到共用物件中（Principal或者Cache) 
            BLLFactory<IApiUserSession>.Instance.SetInfo(Portal.gc.LoginUserInfo);

            await Task.CompletedTask;
        }

通過SetInfo，我們把當前使用者的資訊設定到了域的Principal中，程序內的所有執行緒共用這份使用者資訊資料。

跟蹤介面的呼叫，我們可以檢視到對應的使用者身份資訊了。

可以看到，這個介面已經注入到了服務類中，並且獲得了相應的使用者身份資訊了。

同樣在Web API的登入處理的時候，會生成相關的JWT token的資訊的。

           var loginResult = await this._userService.VerifyUser(dto.LoginName, dto.Password, ip);
            if (loginResult != null && loginResult.UserInfo != null)
            {
                var userInfo = loginResult.UserInfo;

                authResult.AccessToken = GenerateToken(userInfo); //令牌
                authResult.Expires = expiredDays * 24 * 3600; //失效秒數
                authResult.Succes = true;//成功

                //設定快取使用者資訊
                //SetUserCache(userInfo);
            }
            else
            {
                authResult.Error = loginResult?.ErrorMessage;
            }

其中生成的JWT token的邏輯如下所示。

        /// <summary>
        /// 生成JWT使用者令牌
        /// </summary>
        /// <returns></returns>
        private string GenerateToken(UserInfo userInfo)
        {
            var claims = new List<Claim>
            {
                new Claim(ApiUserClaimTypes.Id, userInfo.Id.ToString()),
                new Claim(ApiUserClaimTypes.Email, userInfo.Email),
                new Claim(ApiUserClaimTypes.Name, userInfo.Name),
                new Claim(ApiUserClaimTypes.NickName, userInfo.Nickname),
                new Claim(ApiUserClaimTypes.PhoneNumber, userInfo.MobilePhone),
                new Claim(ApiUserClaimTypes.Gender, userInfo.Gender),

                new Claim(ApiUserClaimTypes.FullName, userInfo.FullName),
                new Claim(ApiUserClaimTypes.Company_ID, userInfo.Company_ID),
                new Claim(ApiUserClaimTypes.CompanyName, userInfo.CompanyName),
                new Claim(ApiUserClaimTypes.Dept_ID, userInfo.Dept_ID),
                new Claim(ApiUserClaimTypes.DeptName, userInfo.DeptName),
            };

            var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Secret"]));
            var jwt = new JwtSecurityToken
            (
                issuer: _configuration["Jwt:Issuer"],
                audience: _configuration["Jwt:Audience"],
                claims: claims,
                expires: DateTime.Now.AddDays(expiredDays),//有效時間
                signingCredentials: new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256)
             );
            var token = new JwtSecurityTokenHandler().WriteToken(jwt);
            return token;
        }

說生成的一系列字串，我們可以通過解碼工具，可以解析出來對應的資訊的。

在登入授權的這個時候，控制器會把相關的Claim資訊寫入到token中的，我們在使用者端發起對控制器方法的呼叫的時候，這些身份資訊會轉換成物件資訊。

我們偵錯控制器的方法入口，如可以通過Fiddler的測試介面的呼叫情況。

可以看到CurrentApiUser的資訊就是我們發起使用者身份資訊，如下圖所示。

在監視視窗中檢視IApiUserSession物件,可以檢視到對應的資訊。

3、基於記憶體快取的使用者身份介面實現處理方式

在前面介紹的IApiUserSession的介面實現的時候，我們也提供了另外一個基於MemoryCache的快取實現方式，和基於Principal憑證資訊處理不同，我們這個是基於MemoryCache的儲存方式。

它的實現方法也是類似的，我們這裡也一併介紹一下。

    /// <summary>
    /// 基於MemeoryCache實現的使用者資訊介面
    /// </summary>
    public class ApiUserCache : IApiUserSession
    {
        /// <summary>
        /// 記憶體快取物件
        /// </summary>
        private static readonly ObjectCache Cache = MemoryCache.Default;

        /// <summary>
        /// 預設建構函式
        /// </summary>
        public ApiUserCache()
        {
        }

        /// <summary>
        /// 把使用者資訊設定到快取中去
        /// </summary>
        /// <param name="info">使用者登陸資訊</param>
        public void SetInfo(LoginUserInfo info, string channel = null)
        {
            SetItem(ApiUserClaimTypes.Id, info.ID);
            SetItem(ApiUserClaimTypes.Name, info.UserName);
            SetItem(ApiUserClaimTypes.Email, info.Email);
            SetItem(ApiUserClaimTypes.PhoneNumber, info.MobilePhone);
            SetItem(ApiUserClaimTypes.Gender, info.Gender);
            SetItem(ApiUserClaimTypes.FullName, info.FullName);
            SetItem(ApiUserClaimTypes.Company_ID, info.CompanyId);
            SetItem(ApiUserClaimTypes.CompanyName, info.CompanyName);
            SetItem(ApiUserClaimTypes.Dept_ID, info.DeptId);
            SetItem(ApiUserClaimTypes.DeptName, info.DeptName);
        }

        /// <summary>
        /// 設定某個屬性物件
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        private void SetItem(string key, object value)
        {
            if (!string.IsNullOrEmpty(key))
            {
                Cache.Set(key, value ?? "", DateTimeOffset.MaxValue, null);
            }
        }

        /// <summary>
        /// 使用者ID
        /// </summary>
        public int? Id => (Cache.Get(ApiUserClaimTypes.Id) as string)?.ToInt32();

        /// <summary>
        /// 使用者名稱稱
        /// </summary>
        public string Name => Cache.Get(ApiUserClaimTypes.Name) as string;

        /// <summary>
        /// 使用者郵箱（可選）   
        /// </summary>
        public string Email => Cache.Get(ApiUserClaimTypes.Email) as string;

         ..............
    }

我們通過 MemoryCache.Default 構造一個記憶體快取的物件，然後在設定資訊的時候，把使用者資訊按照鍵值方式設定即可。在Winform中我們可以採用記憶體快取的方式儲存使用者身份資訊，而基於Web方式的，則會存在並行多個使用者的情況，不能用快取來處理。

一般情況下，我們採用 ApiUserPrincipal 來處理使用者身份資訊就很好了。

4、單元測試的使用者身份處理

在做單元測試的時候，我們如果需要設定測試介面的使用者身份資訊，那麼就需要在初始化函數裡面設定好使用者資訊，如下所示。

    [TestClass]
    public class UnitTest1
    {
        private static IServiceProvider Provider = null;

        /*
        帶有[ClassInitialize()] 特性的方法在執行類中第一個測試之前呼叫。
        帶有[TestInitialize()] 特性的方法在執行每個測試前都會被呼叫，一般用來初始化環境，為單元測試設定一個特定已知的狀態。
        帶有[ClassCleanup()] 特性的方法將在類中所有的測試執行完後執行。
        */
        //[TestInitialize] //每個測試前呼叫
        [ClassInitialize] //測試類第一次呼叫
        public static void Setup(TestContext context)
        {
            // IServiceCollection負責註冊
            IServiceCollection services = new ServiceCollection();
            //呼叫自定義的服務註冊
            ServiceInjection.ConfigureRepository(services);

            //注入當前Api使用者資訊處理實現,服務物件可以通過IApiUserSession獲得使用者資訊
            //services.AddSingleton<IApiUserSession, ApiUserCache>(); //快取實現方式
            services.AddSingleton<IApiUserSession, ApiUserPrincipal>(); //CurrentPrincipal實現方式

            // IServiceProvider負責提供範例
            Provider = services.BuildServiceProvider();

            //模擬寫入登入使用者資訊
            WriteLoginInfo();
        }

        /// <summary>
        /// 寫入使用者登陸資訊，IApiUserSession介面才可使用獲取身份
        /// </summary>
        static void WriteLoginInfo()
        {
            var mockUserInfo = new LoginUserInfo()
            {
                ID = "1",
                Email = "[email protected]",
                MobilePhone = "18620292076",
                UserName = "admin",
                FullName = "伍華聰"
            };

            //通過使用全域性IServiceProvider的介面獲得服務介面範例
            Provider.GetService<IApiUserSession>().SetInfo(mockUserInfo);
        }

上面的方法初始化了測試類的資訊，方法呼叫的時候，我們獲得對應的介面範例處理即可，如下測試程式碼所示。

        /// <summary>
        /// 測試查詢記錄
        /// </summary>
        /// <returns></returns>
        [TestMethod]
        public async Task TestMethod1()
        {
            var input = new DictTypePagedDto()
            {
                Name = "客戶"
            };

            var service = Provider.GetService<IDictTypeService>();
            var count = await service.CountAsync(s => true);
            Assert.AreNotEqual(0, count);

            var list = await service.GetAllAsync();
            Assert.IsNotNull(list);
            Assert.IsNotNull(list.Items);
            Assert.IsTrue(list.Items.Count > 0);

            list = await service.GetListAsync(input);
            Assert.IsNotNull(list);
            Assert.IsNotNull(list.Items);
            Assert.IsTrue(list.Items.Count > 0);

            var ids = list.Items.Select(s => { return s.Id; }).Take(2);
            list = await service.GetAllByIdsAsync(ids);
            Assert.IsNotNull(list);
            Assert.IsNotNull(list.Items);
            Assert.IsTrue(list.Items.Count > 0);


            var id = list.Items[0].Id;
            var info = await service.GetAsync(id);
            Assert.IsNotNull(info);
            Assert.AreEqual(id, info.Id);

            info = await service.GetFirstAsync(s => true);
            Assert.IsNotNull(info);

            await Task.CompletedTask;
        }

系列文章：

《基於SqlSugar的開發框架的循序漸進介紹（1）--框架基礎類的設計和使用》

《基於SqlSugar的開發框架循序漸進介紹（2）-- 基於中間表的查詢處理》

《基於SqlSugar的開發框架循序漸進介紹（3）-- 實現程式碼生成工具Database2Sharp的整合開發》

《基於SqlSugar的開發框架循序漸進介紹（4）-- 在資料存取基礎類別中對GUID主鍵進行自動賦值處理》

《基於SqlSugar的開發框架循序漸進介紹（5）-- 在服務層使用介面注入方式實現IOC控制反轉》

《基於SqlSugar的開發框架循序漸進介紹（6）-- 在基礎類別介面中注入使用者身份資訊介面》