愚公系列2023年03月 MES生产制造执行系统-001.Autofac的使用

---

前言

IoC容器是一种设计模式，它可以管理应用程序中的对象依赖关系。它可以自动创建和注入对象，从而减少了代码的耦合度和重复性。

Autofac是Microsoft .NET的IoC容器。它管理类之间的依赖关系，以便应用程序在大小和复杂性增加时易于更改。这是通过将常规 .NET 类视为组件来实现的。

Autofac的官网：https://autofac.org/

Autofac的源码网址：https://gitee.com/dennisdyh/Autofac.Extensions.DependencyInjection

一、Autofac的使用

1.安装包

Autofac.Extensions.DependencyInjection

2.服务注入

在Program注入Autofac服务

public static IHostBuilder CreateHostBuilder(string[] args) =>
       Host.CreateDefaultBuilder(args)
           .ConfigureWebHostDefaults(webBuilder =>
           {
               webBuilder.ConfigureKestrel(serverOptions =>
               {
                   serverOptions.Limits.MaxRequestBodySize = 10485760;
                   // Set properties and call methods on options
               });
               webBuilder.UseKestrel().UseUrls("http://*:9991");
               webBuilder.UseIIS();
               webBuilder.UseStartup<Startup>();
           }).UseServiceProviderFactory(new AutofacServiceProviderFactory());//设置工厂来替换实例

在Startup中增加ConfigureContainer方法，用来配置映射关系

public void ConfigureContainer(ContainerBuilder builder)
{
    Services.AddModule(builder, Configuration);
}

使用了Autofac以后，在IServiceCollection中注入的服务，也能生效；因为Autofac是先接受了所有的来自于IServiceCollection的服务映射后，再去读取ConfigureContainer方法中配置的映射。

3.AddModule扩展方法详解

AddModule包含了反射注入容器和一堆服务注入容器

//  private static bool _isMysql = false;
public static IServiceCollection AddModule(this IServiceCollection services, ContainerBuilder builder, IConfiguration configuration)
{
    //services.AddSession();
    //services.AddMemoryCache();
    //初始化配置文件
    AppSetting.Init(services, configuration);
    Type baseType = typeof(IDependency);
    var compilationLibrary = DependencyContext.Default
        .RuntimeLibraries
        .Where(x => !x.Serviceable
        && x.Type == "project")
        .ToList();
    var count1 = compilationLibrary.Count;
    List<Assembly> assemblyList = new List<Assembly>();

    foreach (var _compilation in compilationLibrary)
    {
        try
        {
            assemblyList.Add(AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(_compilation.Name)));
        }
        catch (Exception ex)
        {
            Console.WriteLine(_compilation.Name   ex.Message);
        }
    }
    builder.RegisterAssemblyTypes(assemblyList.ToArray())
     .Where(type => baseType.IsAssignableFrom(type) && !type.IsAbstract)
     .AsSelf().AsImplementedInterfaces()
     .InstancePerLifetimeScope();
    builder.RegisterType<UserContext>().InstancePerLifetimeScope();
    builder.RegisterType<ActionObserver>().InstancePerLifetimeScope();
    //model校验结果
    builder.RegisterType<ObjectModelValidatorState>().InstancePerLifetimeScope();
    string connectionString = DBServerProvider.GetConnectionString(null);

    if (DBType.Name == DbCurrentType.MySql.ToString())
    {
        //增加dapper对mysql字段Guid映射
        SqlMapper.AddTypeHandler(new DapperParseGuidTypeHandler());
        SqlMapper.RemoveTypeMap(typeof(Guid?));

        //services.AddDbContext<SysDbContext>();
        //mysql8.x的版本使用Pomelo.EntityFrameworkCore.MySql 3.1会产生异常，需要在字符串连接上添加allowPublicKeyRetrieval=true
        services.AddDbContextPool<SysDbContext>(optionsBuilder => { optionsBuilder.UseMySql(connectionString); }, 64);
        services.AddDbContextPool<ServiceDbContext>(optionsBuilder => { optionsBuilder.UseMySql(connectionString); }, 64);
        services.AddDbContextPool<ReportDbContext>(optionsBuilder => { optionsBuilder.UseMySql(connectionString); }, 64);
    }
    else if (DBType.Name == DbCurrentType.PgSql.ToString())
    {
        services.AddDbContextPool<SysDbContext>(optionsBuilder => { optionsBuilder.UseNpgsql(connectionString); }, 64);
        services.AddDbContextPool<ServiceDbContext>(optionsBuilder => { optionsBuilder.UseNpgsql(connectionString); }, 64);
        services.AddDbContextPool<ReportDbContext>(optionsBuilder => { optionsBuilder.UseNpgsql(connectionString); }, 64);
    }
    else
    {
        services.AddDbContextPool<SysDbContext>(optionsBuilder => { optionsBuilder.UseSqlServer(connectionString); }, 64);
        services.AddDbContextPool<ServiceDbContext>(optionsBuilder => { optionsBuilder.UseSqlServer(connectionString); }, 64);
        services.AddDbContextPool<ReportDbContext>(optionsBuilder => { optionsBuilder.UseSqlServer(connectionString); }, 64);
    }
    //启用缓存
    if (AppSetting.UseRedis)
    {
        builder.RegisterType<RedisCacheService>().As<ICacheService>().SingleInstance();
    }
    else
    {
        builder.RegisterType<MemoryCacheService>().As<ICacheService>().SingleInstance();
    }
    //kafka注入
    //if (AppSetting.Kafka.UseConsumer)
    //    builder.RegisterType<KafkaConsumer<string, string>>().As<IKafkaConsumer<string, string>>().SingleInstance();
    //if (AppSetting.Kafka.UseProducer)
    //    builder.RegisterType<KafkaProducer<string, string>>().As<IKafkaProducer<string, string>>().SingleInstance();
    return services;
}

3.1 AppSetting.Init

应用程序初始化主要是对配置文件使用

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "VirtualPath": {
    "StaticFile": "E:\\Web\\Static", //配置的虚拟目录文件所在路径
    "FolderName": "/Static" //访问时此路径时的别名
  },
  "AppUrls": {
  },
  "Connection": {
    "DBType": "MsSql", //MySql/MsSql/PgSql  //数据库类型，如果使用的是sqlserver此处应设置为MsSql
    //sqlserver连接字符串
    "DbConnectionString": "Data Source=.;Initial Catalog=iMES_Open;Persist Security Info=True;User ID=sa;Password=1;Connect Timeout=500;",

    //mysql连接字符串(升级EFCore3.1到时已将mysql连接字符串修改,2019-12-20)
    //"DbConnectionString": " Data Source=127.0.0.1;Database=imes_open;AllowLoadLocalInfile=true;User ID=root;Password=123456;allowPublicKeyRetrieval=true;pooling=true;CharSet=utf8;port=3306;sslmode=none;",

    //PgSql连接字符串
    //  "DbConnectionString": "Host=132.232.2.109;Port=5432;User id=postgres;password=jxx_abcd;Database=netcoredev;",
    "RedisConnectionString": "127.0.0.1,Password=123456,SyncTimeout=15000", //redis连接字符串(最好加密)
    "UseRedis": "false", //是否使用redis，如果不使用，默认使用Memory内置缓存
    "UseSignalR": "true" //是否使用SignalR(2022.05.03)，注意需要将端的地址配置到下面的CorsUrls属性中
  },
  //业务数据库连接
  "ServiceConnectingString": "Data Source=.;Initial Catalog=iMES;Persist Security Info=True;User ID=sa;Password=123456;Connect Timeout=500;",
  //报表数据库连接
  "ReportConnectingString": "Data Source=.;Initial Catalog=iMES;Persist Security Info=True;User ID=sa;Password=123456;Connect Timeout=500;",
  "Secret": { //秘钥配置
    "JWT": "BB3647441FFA4B5DB4E64A29B53CE525", //JWT
    "Audience": "iMES.core",
    "Issuer": "iMES.core.owner",
    "User": "C5ABA9E202D94C43A3CA66002BF77FAF", //
    "DB": "3F8B7B38AD3D484A89ACA513CBD79F36",
    "Redis": "E6D90DDBC70C4F4EA3C312B6FCB473C8"
  },
  //================跨域请求 (CORS)配置(2019-12-20新增)，
  //================.netcore3.1必须配置此属性,多个url用豆号隔开,url为vue站点的地址，可以将发布后的地址也同时配置上
  "CorsUrls": "http://localhost:8081,http://localhost:8082,http://localhost:8080,http://localhost:7080,http://localhost:9980,http://127.0.0.1:9980,http://localhost:9990,http://www.volcore.xyz,http://app.625sc.com,https://imes.625sc.com",
  "ExpMinutes": "120", //JWT有效期(分钟=默认120),
  "CreateMember": { //对表插入数据时，需要记录创建人/创建时间/创建日期,配置UserIdField/UserNameField/DateField分别为对应数据库的创建人CreateID,创建人Creator,创建时间CreateDate字段(新建数据时,由框架默认完成给这几个字段赋值,字段区分大小写)或可手动调用T.SetCreateDefaultVal()完成设置创建人/创建时间/创建日期
    //如果表的主键是GUID，界面查询时默认会用到DateField对应的实体(数据库)字段进行排序
    "UserIdField": "CreateID",
    "UserNameField": "Creator",
    "DateField": "CreateDate"
  },
  "ModifyMember": { //修改同上
    "UserIdField": "ModifyID",
    "UserNameField": "Modifier",
    "DateField": "ModifyDate"
  }, //演示系统过滤Action，只有超级管理员才能操作，其他用户只有只读权限
  "GlobalFilter": {
    "Message": "演示环境,当前帐号没有开启此功能权限",
    "Enable": "false", //开启Action过滤
    "Actions": [ "Update", "Del", "Add", "SavePermission", "Save", "CreatePage", "CreateVuePage", "CreateEntityModel", "SaveEidt", "CreateServices", "Import", "Upload", "Audit", "ModifyPwd" ]
  },
  "Kafka": {
    //是否使用生产者
    "UseProducer": false,
    "ProducerSettings": {
      "BootstrapServers": "192.168.20.241:9092", //confluent cloud bootstrap servers
      "SaslMechanism": "Plain",
      "SecurityProtocol": "SaslSsl",
      "SaslUsername": "<confluent cloud key>",
      "SaslPassword": "<confluent cloud secret>"
    },
    //是否使用消费者
    "UseConsumer": false,
    //是否持续监听消费者订阅 用于while循环订阅
    "IsConsumerSubscribe": true,
    "ConsumerSettings": {
      "BootstrapServers": "192.168.20.241:9092", //confluent cloud bootstrap servers
      "GroupId": "amcl_group", //web-example-group
      "SaslMechanism": "Plain",
      "SecurityProtocol": "SaslSsl",
      "SaslUsername": "<confluent cloud key>",
      "SaslPassword": "<confluent cloud secret>"
    },
    "Topics": {
      "TestTopic": "alarm_topic"
    }
  },
  "Mail": {
    "Address": "zm_rid@163.com", //发件的邮箱
    "Host": "smtp.163.com",
    "Name": "iMES", //发送人名称
    "Port": 25,
    "EnableSsl": false,
    "AuthPwd": "授权密码" //授权密码（对应邮箱设置里面去开启）
  },
  "QuartzAccessKey": "65EC9387312E4717810C552963CE59FF", //定时任务的值
  "ExportPDFPath": "C:\\iMES_Open\\iMES_Front\\PDF" //导出PDF路径
}

public static void Init(IServiceCollection services, IConfiguration configuration)
{
    //---------------------------------配置信息服务类的映射------------------------------
    Configuration = configuration;
    services.Configure<Secret>(configuration.GetSection("Secret"));
    services.Configure<Connection>(configuration.GetSection("Connection"));
    services.Configure<CreateMember>(configuration.GetSection("CreateMember"));
    services.Configure<ModifyMember>(configuration.GetSection("ModifyMember"));
    services.Configure<GlobalFilter>(configuration.GetSection("GlobalFilter"));
    services.Configure<Kafka>(configuration.GetSection("Kafka"));
    //---------------------------------获取当前程序目录-----------------------------------
    var provider = services.BuildServiceProvider();
    IWebHostEnvironment environment = provider.GetRequiredService<IWebHostEnvironment>();
    CurrentPath = Path.Combine(environment.ContentRootPath, "").ReplacePath();
    //---------------------------------获取各种配置操作类-------------------------------------
    Secret = provider.GetRequiredService<IOptions<Secret>>().Value;

    //设置修改或删除时需要设置为默认用户信息的字段
    CreateMember = provider.GetRequiredService<IOptions<CreateMember>>().Value ?? new CreateMember();
    ModifyMember = provider.GetRequiredService<IOptions<ModifyMember>>().Value ?? new ModifyMember();
    //全局过滤行为
    GlobalFilter = provider.GetRequiredService<IOptions<GlobalFilter>>().Value ?? new GlobalFilter();

    GlobalFilter.Actions = GlobalFilter.Actions ?? new string[0];
    //Kafka消息队列
    Kafka = provider.GetRequiredService<IOptions<Kafka>>().Value ?? new Kafka();
    //各种数据库和缓存数据库连接字符串
    _connection = provider.GetRequiredService<IOptions<Connection>>().Value;
    //JWT过期时间
    ExpMinutes = (configuration["ExpMinutes"] ?? "120").GetInt();

    //判断数据库是否存在
    DBType.Name = _connection.DBType;
    if (string.IsNullOrEmpty(_connection.DbConnectionString))
        throw new System.Exception("未配置好数据库默认连接");
    //进行数据库解密（解密失败返回原字符串,成功返回新字符串）
    try
    {
        _connection.DbConnectionString = _connection.DbConnectionString.DecryptDES(Secret.DB);
    }
    catch { }

    if (!string.IsNullOrEmpty(_connection.RedisConnectionString))
    {
        try
        {
            _connection.RedisConnectionString = _connection.RedisConnectionString.DecryptDES(Secret.Redis);
        }
        catch { }
    }

}

3.1.1 数据库字符串加/解密

public static class SecurityEncDecryptExtensions
{

    private static byte[] Keys = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
    /// <summary> 
    /// DES加密字符串 
    /// </summary> 
    /// <param name="encryptString">待加密的字符串</param> 
    /// <param name="encryptKey">加密密钥,要求为16位</param> 
    /// <returns>加密成功返回加密后的字符串，失败返回源串</returns> 

    public static string EncryptDES(this string encryptString, string encryptKey)
    {
        try
        {
            byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 16));
            byte[] rgbIV = Keys;
            byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);

            using (var DCSP = Aes.Create())
            {
                using (MemoryStream mStream = new MemoryStream())
                {
                    using (CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(inputByteArray, 0, inputByteArray.Length);
                        cStream.FlushFinalBlock();
                        return Convert.ToBase64String(mStream.ToArray()).Replace(' ', '_').Replace('/', '~');
                    }
                }
            }
        }
        catch (Exception ex)
        {
            throw new Exception("密码加密异常"   ex.Message);
        }

    }

    /// <summary> 
    /// DES解密字符串 
    /// </summary> 
    /// <param name="decryptString">待解密的字符串</param> 
    /// <param name="decryptKey">解密密钥,要求为16位,和加密密钥相同</param> 
    /// <returns>解密成功返回解密后的字符串，失败返源串</returns> 

    public static string DecryptDES(this string decryptString, string decryptKey)
    {
        byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey.Substring(0, 16));
        byte[] rgbIV = Keys;
        byte[] inputByteArray = Convert.FromBase64String(decryptString.Replace('_', ' ').Replace('~', '/'));
        using (var DCSP = Aes.Create())
        {
            using (MemoryStream mStream = new MemoryStream())
            {
                using (CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
                {
                    byte[] inputByteArrays = new byte[inputByteArray.Length];
                    cStream.Write(inputByteArray, 0, inputByteArray.Length);
                    cStream.FlushFinalBlock();
                    return Encoding.UTF8.GetString(mStream.ToArray());
                }
            }
        }

    }
    public static bool TryDecryptDES(this string decryptString, string decryptKey, out string result)
    {
        result = "";
        try
        {
            result = DecryptDES(decryptString, decryptKey);
            return true;
        }
        catch
        {
            return false;
        }
    }
}

3.2 Autofac相关服务类

3.2.1 UserContext

UserContext主要作用就是记录用户信息

public class UserContext
{
    /// <summary>
    /// 为了尽量减少redis或Memory读取,保证执行效率,将UserContext注入到DI，
    /// 每个UserContext的属性至多读取一次redis或Memory缓存从而提高查询效率
    /// </summary>
    public static UserContext Current
    {
        get
        {
            return Context.RequestServices.GetService(typeof(UserContext)) as UserContext;
        }
    }

    private static Microsoft.AspNetCore.Http.HttpContext Context
    {
        get
        {
            return Utilities.HttpContext.Current;
        }
    }
    private static ICacheService CacheService
    {
        get { return GetService<ICacheService>(); }
    }

    private static T GetService<T>() where T : class
    {
        return AutofacContainerModule.GetService<T>();
    }

    public UserInfo UserInfo
    {
        get
        {
            if (_userInfo != null)
            {
                return _userInfo;
            }
            return GetUserInfo(UserId);
        }
    }

    private UserInfo _userInfo { get; set; }

    /// <summary>
    /// 角色ID为1的默认为超级管理员
    /// </summary>
    public bool IsSuperAdmin
    {
        get { return IsRoleIdSuperAdmin(this.RoleId); }
    }
    /// <summary>
    /// 角色ID为1的默认为超级管理员
    /// </summary>
    public static bool IsRoleIdSuperAdmin(int roleId)
    {
        return roleId == 1;
    }

    public UserInfo GetUserInfo(int userId)
    {
        if (_userInfo != null) return _userInfo;
        if (userId <= 0)
        {
            _userInfo = new UserInfo();
            return _userInfo;
        }
        string key = userId.GetUserIdKey();
        _userInfo = CacheService.Get<UserInfo>(key);
        if (_userInfo != null && _userInfo.User_Id > 0) return _userInfo;

        _userInfo = DBServerProvider.DbContext.Set<Sys_User>()
            .Where(x => x.User_Id == userId).Select(s => new UserInfo()
            {
                User_Id = userId,
                Role_Id = s.Role_Id.GetInt(),
                RoleName = s.RoleName,
                //2022.08.15增加部门id
                DeptId = s.Dept_Id??0,
                Token = s.Token,
                UserName = s.UserName,
                UserTrueName = s.UserTrueName,
                Enable = s.Enable
            }).FirstOrDefault();

        if (_userInfo != null && _userInfo.User_Id > 0)
        {
            CacheService.AddObject(key, _userInfo);
        }
        return _userInfo ?? new UserInfo();
    }

    /// <summary>
    /// 获取角色权限时通过安全字典锁定的角色id
    /// </summary>
    private static ConcurrentDictionary<string, object> objKeyValue = new ConcurrentDictionary<string, object>();

    /// <summary>
    /// 角色权限的版本号
    /// </summary>
    private static readonly Dictionary<int, string> rolePermissionsVersion = new Dictionary<int, string>();

    /// <summary>
    /// 每个角色ID对应的菜单权限（已做静态化处理）
    /// 每次获取权限时用当前服务器的版本号与redis/memory缓存的版本比较,如果不同会重新刷新缓存
    /// </summary>
    private static readonly Dictionary<int, List<Permissions>> rolePermissions = new Dictionary<int, List<Permissions>>();



    /// <summary>
    /// 获取用户所有的菜单权限
    /// </summary>

    public List<Permissions> Permissions
    {
        get
        {
            return GetPermissions(RoleId);
        }
    }

    /// <summary>
    /// 菜单按钮变更时，同时刷新权限缓存2022.05.23
    /// </summary>
    /// <param name="menuId"></param>
    public void RefreshWithMenuActionChange(int menuId)
    {
        foreach (var roleId in rolePermissions.Where(c => c.Value.Any(x => x.Menu_Id == menuId)).Select(s => s.Key))
        {
            if (rolePermissionsVersion.ContainsKey(roleId))
            {
                CacheService.Add(roleId.GetRoleIdKey(), DateTime.Now.ToString("yyyyMMddHHMMssfff"));
            }
        }

    }

    /// <summary>
    /// 获取单个表的权限
    /// </summary>
    /// <param name="tableName"></param>
    /// <returns></returns>
    public Permissions GetPermissions(string tableName)
    {
        return GetPermissions(RoleId).Where(x => x.TableName == tableName).FirstOrDefault();
    }
    /// <summary>
    /// 2022.03.26
    /// 菜单类型1:移动端，0:PC端
    /// </summary>
    public static int MenuType
    {
        get
        {
            return Context.Request.Headers.ContainsKey("uapp") ? 1 : 0;
        }
    }
    /// <summary>
    /// 自定条件查询权限
    /// </summary>
    /// <param name="func"></param>
    /// <returns></returns>
    public Permissions GetPermissions(Func<Permissions, bool> func)
    {
        // 2022.03.26增移动端加菜单类型判断
        return GetPermissions(RoleId).Where(func).Where(x => x.MenuType == MenuType).FirstOrDefault();
    }

    private List<Permissions> ActionToArray(List<Permissions> permissions)
    {
        permissions.ForEach(x =>
        {
            try
            {
                var menuAuthArr = x.MenuAuth.DeserializeObject<List<Sys_Actions>>();
                x.UserAuthArr = string.IsNullOrEmpty(x.UserAuth)
                ? new string[0]
                : x.UserAuth.Split(",").Where(c => menuAuthArr.Any(m => m.Value == c)).ToArray();

            }
            catch { }
            finally
            {
                if (x.UserAuthArr == null)
                {
                    x.UserAuthArr = new string[0];
                }
            }
        });
        return permissions;
    }
    private List<Permissions> MenuActionToArray(List<Permissions> permissions)
    {
        permissions.ForEach(x =>
        {
            try
            {
                x.UserAuthArr = string.IsNullOrEmpty(x.UserAuth)
                ? new string[0]
                : x.UserAuth.DeserializeObject<List<Sys_Actions>>().Select(s => s.Value).ToArray();
            }
            catch { }
            finally
            {
                if (x.UserAuthArr == null)
                {
                    x.UserAuthArr = new string[0];
                }
            }
        });
        return permissions;
    }
    public List<Permissions> GetPermissions(int roleId)
    {
        if (IsRoleIdSuperAdmin(roleId))
        {
            //2020.12.27增加菜单界面上不显示，但可以分配权限
            var permissions = DBServerProvider.DbContext.Set<Sys_Menu>()
                .Where(x => x.Enable == 1 || x.Enable == 2)
                .Select(a => new Permissions
                {
                    Menu_Id = a.Menu_Id,
                    ParentId = a.ParentId,
                    //2020.05.06增加默认将表名转换成小写，权限验证时不再转换
                    TableName = (a.TableName ?? "").ToLower(),
                    //MenuAuth = a.Auth,
                    UserAuth = a.Auth,
                    // 2022.03.26增移动端加菜单类型
                    MenuType = a.MenuType ?? 0
                }).ToList();
            return MenuActionToArray(permissions);
        }
        ICacheService cacheService = CacheService;
        string roleKey = roleId.GetRoleIdKey();

        //角色有缓存，并且当前服务器的角色版本号与redis/memory缓存角色的版本号相同直接返回静态对象角色权限
        string currnetVeriosn = "";
        if (rolePermissionsVersion.TryGetValue(roleId, out currnetVeriosn)
            && currnetVeriosn == cacheService.Get(roleKey))
        {
            return rolePermissions.ContainsKey(roleId) ? rolePermissions[roleId] : new List<Permissions>();
        }

        //锁定每个角色，通过安全字典减少锁粒度，否则多个同时角色获取缓存会导致阻塞
        object objId = objKeyValue.GetOrAdd(roleId.ToString(), new object());
        //锁定每个角色
        lock (objId)
        {
            if (rolePermissionsVersion.TryGetValue(roleId, out currnetVeriosn)
                && currnetVeriosn == cacheService.Get(roleKey))
            {
                return rolePermissions.ContainsKey(roleId) ? rolePermissions[roleId] : new List<Permissions>();
            }

            //没有redis/memory缓存角色的版本号或与当前服务器的角色版本号不同时，刷新缓存
            var dbContext = DBServerProvider.DbContext;
            List<Permissions> _permissions = (from a in dbContext.Set<Sys_Menu>()
                                              join b in dbContext.Set<Sys_RoleAuth>()
                                              on a.Menu_Id equals b.Menu_Id
                                              where b.Role_Id == roleId //&& a.ParentId > 0
                                              && b.AuthValue != ""
                                              orderby a.ParentId
                                              select new Permissions
                                              {
                                                  Menu_Id = a.Menu_Id,
                                                  ParentId = a.ParentId,
                                                  //2020.05.06增加默认将表名转换成小写，权限验证时不再转换
                                                  TableName = (a.TableName ?? "").ToLower(),
                                                  MenuAuth = a.Auth,
                                                  UserAuth = b.AuthValue ?? "",
                                                  // 2022.03.26增移动端加菜单类型
                                                  MenuType = a.MenuType ?? 0
                                              }).ToList();
            ActionToArray(_permissions);
            string _version = cacheService.Get(roleKey);
            //生成一个唯一版本号标识
            if (_version == null)
            {
                _version = DateTime.Now.ToString("yyyyMMddHHMMssfff");
                //将版本号写入缓存
                cacheService.Add(roleKey, _version);
            }
            //刷新当前服务器角色的权限
            rolePermissions[roleId] = _permissions;

            //写入当前服务器的角色最新版本号
            rolePermissionsVersion[roleId] = _version;
            return _permissions;
        }

    }

    /// <summary>
    /// 判断是否有权限
    /// </summary>
    /// <param name="tableName"></param>
    /// <param name="authName"></param>
    /// <param name="roleId"></param>
    /// <returns></returns>
    public bool ExistsPermissions(string tableName, string authName, int roleId = 0)
    {
        if (roleId <= 0) roleId = RoleId;
        tableName = tableName.ToLower();
        return GetPermissions(roleId).Any(x => x.TableName == tableName && x.UserAuthArr.Contains(authName));
    }

    /// <summary>
    /// 判断是否有权限
    /// </summary>
    /// <param name="tableName"></param>
    /// <param name="authName"></param>
    /// <param name="roleId"></param>
    /// <returns></returns>
    public bool ExistsPermissions(string tableName, ActionPermissionOptions actionPermission, int roleId = 0)
    {
        return ExistsPermissions(tableName, actionPermission.ToString(), roleId);
    }
    public int UserId
    {
        get
        {
            return (Context.User.FindFirstValue(JwtRegisteredClaimNames.Jti)
                ?? Context.User.FindFirstValue(ClaimTypes.NameIdentifier)).GetInt();
        }
    }

    public string UserName
    {
        get { return UserInfo.UserName; }
    }

    public string UserTrueName
    {
        get { return UserInfo.UserTrueName; }
    }

    public string Token
    {
        get { return UserInfo.Token; }
    }

    public int RoleId
    {
        get { return UserInfo.Role_Id; }
    }

    public void LogOut(int userId)
    {
        CacheService.Remove(userId.GetUserIdKey());
    }
}

3.2.2 ActionObserver

ActionObserver记录Action执行的信息

public class ActionObserver
{
    //public ActionObserver(IHttpContextAccessor httpContextAccessor)
    //{
    //    this.RequestDate = DateTime.Now;
    //    this.HttpContext = httpContextAccessor.HttpContext;
    //}
    /// <summary>
    /// 记录action执行的开始时间
    /// </summary>
    public DateTime RequestDate { get; set; }

    /// <summary>
    /// 当前请求是否已经写过日志,防止手动与系统自动重复写日志
    /// </summary>
    public bool IsWrite { get; set; }

    public HttpContext HttpContext { get; }
}

3.2.3 ObjectModelValidatorState

ObjectModelValidatorState 对象模型校验服务

public class ObjectModelValidatorState
{
    public ObjectModelValidatorState()
    {
        this.Status = true;
    }

    public bool Status { get; set; }
    public bool HasModelContent { get; set; }
    public string Code { get; set; }
    public string Message { get; set; }
}
public class ObjectValidatorResult
{
    public ObjectValidatorResult()
    {

    }
    public ObjectValidatorResult(bool status)
    {
        this.Status = status;
    }
    public ObjectValidatorResult OK(string message)
    {
        this.Status = true;
        this.Message = message;
        return this;
    }
    public ObjectValidatorResult Error(string message)
    {
        this.Status = false;
        this.Message = message;
        return this;
    }
    public bool Status { get; set; }
    public string Message { get; set; }
}

其实在Autofac中还注入了数据库服务，下一章讲解。

这篇好文章是转载于：学新通技术网