基于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 = "wuhuacong@163.com",                 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)– 在基类接口中注入用户身份信息接口 

 

商匡云商
Logo
对比商品
  • 合计 (0)
对比
0
购物车