使用 DI 在遗留代码中将拦截器添加到 NHibernate 会话答案

【问题标题】：Using DI to add Interceptor to NHibernate Sessions in legacy code使用 DI 在遗留代码中将拦截器添加到 NHibernate 会话
【发布时间】：2019-10-31 20:40:54
【问题描述】：

所以，我正在维护的一些遗留代码存在错误。它会导致一些轻微的数据损坏，因此相当严重。我已经找到了根本原因，并制作了一个可以可靠地重现该错误的示例应用程序。我想尽可能减少对现有应用程序的影响来修复它，但我很挣扎。

错误在于数据访问层。更具体地说，如何将拦截器注入到新的 Nhibernate Session 中。拦截器用于在保存或刷新时设置特定的实体属性。 LoggedInPersonID 属性几乎可以在我们所有的实体中找到。所有实体都是使用数据库模式从 CodeSmith 模板生成的，因此 LoggedInPersonID 属性对应于在数据库中几乎所有表上都可以找到的列。与其他几个列和触发器一起，它用于跟踪哪个用户在数据库中创建和修改了一条记录。任何插入或更新数据的事务都需要提供 LoggedInPersonID 值，否则事务将失败。

每当客户端需要一个新会话时，都会在 SessionFactory（不是 Nhibernate 的 SessionFactory，而是一个包装器）中调用 OpenSession。下面的代码展示了 SessionFactory 包装类的相关部分：

public class SessionFactory
{
    private ISessionFactory sessionFactory;

    private SessionFactory()
    {
        Init();
    }

    public static SessionFactory Instance
    {
        get
        {
            return Nested.SessionFactory;
        }
    }

    private static readonly object _lock = new object();

    public ISession OpenSession()
    {
        lock (_lock)
        {
            var beforeInitEventArgs = new SessionFactoryOpenSessionEventArgs(null);

            if (BeforeInit != null)
            {
                BeforeInit(this, beforeInitEventArgs);
            }

            ISession session;

            if (beforeInitEventArgs.Interceptor != null
                && beforeInitEventArgs.Interceptor is IInterceptor)
            {
                session = sessionFactory.OpenSession(beforeInitEventArgs.Interceptor);
            }
            else
            {
                session = sessionFactory.OpenSession();
            }

            return session;
        }
    }

    private void Init()
    {
        try
        {
            var configuration = new Configuration().Configure();
            OnSessionFactoryConfiguring(configuration);
            sessionFactory = configuration.BuildSessionFactory();
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine(ex.Message);
            while (ex.InnerException != null)
            {
                Console.Error.WriteLine(ex.Message);
                ex = ex.InnerException;
            }
            throw;
        }
    }

    private void OnSessionFactoryConfiguring(Configuration configuration)
    {
        if(SessionFactoryConfiguring != null)
        {
            SessionFactoryConfiguring(this, new SessionFactoryConfiguringEventArgs(configuration));
        }
    }

    public static event EventHandler<SessionFactoryOpenSessionEventArgs> BeforeInit;
    public static event EventHandler<SessionFactoryOpenSessionEventArgs> AfterInit;
    public static event EventHandler<SessionFactoryConfiguringEventArgs> SessionFactoryConfiguring;

    public class SessionFactoryConfiguringEventArgs : EventArgs
    {
        public Configuration Configuration { get; private set; }

        public SessionFactoryConfiguringEventArgs(Configuration configuration)
        {
            Configuration = configuration;
        }
    }

    public class SessionFactoryOpenSessionEventArgs : EventArgs
    {

        private NHibernate.ISession session;

        public SessionFactoryOpenSessionEventArgs(NHibernate.ISession session)
        {
            this.session = session;
        }

        public NHibernate.ISession Session
        {
            get
            {
                return this.session;
            }
        }

        public NHibernate.IInterceptor Interceptor
        {
            get;
            set;
        }
    }

    /// <summary>
    /// Assists with ensuring thread-safe, lazy singleton
    /// </summary>
    private class Nested
    {
        internal static readonly SessionFactory SessionFactory;

        static Nested()
        {
            try
            {
                SessionFactory  = new SessionFactory();
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine(ex);
                throw;
            }
        }
    }
}

拦截器通过BeforeInit事件注入。下面是拦截器的实现：

public class LoggedInPersonIDInterceptor : NHibernate.EmptyInterceptor
{
    private int? loggedInPersonID
    {
        get
        {
            return this.loggedInPersonIDProvider();
        }
    }

    private Func<int?> loggedInPersonIDProvider;

    public LoggedInPersonIDInterceptor(Func<int?> loggedInPersonIDProvider)
    {
        SetProvider(loggedInPersonIDProvider);
    }

    public void SetProvider(Func<int?> provider)
    {
        loggedInPersonIDProvider = provider;
    }

    public override bool OnFlushDirty(object entity, object id, object[] currentState, object[] previousState,
                                        string[] propertyNames, NHibernate.Type.IType[] types)
    {
        return SetLoggedInPersonID(currentState, propertyNames);
    }

    public override bool OnSave(object entity, object id, object[] currentState,
                          string[] propertyNames, NHibernate.Type.IType[] types)
    {
        return SetLoggedInPersonID(currentState, propertyNames);
    }

    protected bool SetLoggedInPersonID(object[] currentState, string[] propertyNames)
    {
        int max = propertyNames.Length;

        var lipid = loggedInPersonID;

        for (int i = 0; i < max; i++)
        {
            if (propertyNames[i].ToLower() == "loggedinpersonid" && currentState[i] == null && lipid.HasValue)
            {
                currentState[i] = lipid;

                return true;
            }
        }

        return false;
    }
}

以下是应用程序用来注册 BeforeInit 事件处理程序的辅助类：

public static class LoggedInPersonIDInterceptorUtil
    {
        public static LoggedInPersonIDInterceptor Setup(Func<int?> loggedInPersonIDProvider)
        {
            var loggedInPersonIdInterceptor = new LoggedInPersonIDInterceptor(loggedInPersonIDProvider);

            ShipRepDAL.ShipRepDAO.SessionFactory.BeforeInit += (s, args) =>
            {    
                args.Interceptor = loggedInPersonIdInterceptor;
            };

            return loggedInPersonIdInterceptor;
        }
    }
}

该错误在我们的 Web 服务 (WCF SOAP) 中尤为突出。 Web 服务端点绑定都是 basicHttpBinding。为每个客户端请求创建一个新的 Nhibernate 会话。 LoggedInPersonIDInterceptorUtil.Setup 方法在客户端通过身份验证后调用，并在闭包中捕获经过身份验证的客户端 ID。然后，在另一个客户端请求使用不同的闭包向 BeforeInit 事件注册事件处理程序之前，就会有一个代码竞赛触发对 SessionFactory.OpenSession 的调用 - 因为，它是 BeforeInit 事件的调用列表中“获胜”的最后一个处理程序，可能会返回错误的拦截器。该错误通常发生在两个客户端几乎同时发出请求时，但也发生在两个客户端客户端以不同的执行时间调用不同的 Web 服务方法（一个从身份验证到 OpenSession 的时间比另一个要长）。

除了数据损坏之外，还有内存泄漏，因为事件处理程序没有取消注册？这可能是我们的 Web 服务进程每天至少回收一次的原因？

看起来确实需要 BeforeInit（和 AfterInit）事件。我可以更改 OpenSession 方法的签名，并添加一个 IInterceptor 参数。但这会破坏很多代码，而且我不想在检索会话时传入拦截器 - 我希望这是透明的。由于拦截器在所有使用 DAL 的应用程序中都是一个横切关注点，依赖注入会是一个可行的解决方案吗？ Unity 用于我们应用程序的其他一些领域。

任何朝着正确方向的轻推将不胜感激:)

【问题讨论】：

标签： c# nhibernate dependency-injection unity-container

【解决方案1】：

我不会在每个 ISessionFactory.OpenSession 调用中提供拦截器，而是使用全局配置的单个拦截器实例 (Configuration.SetInterceptor())。

此实例将从适当的上下文中检索要使用的数据，从而允许根据请求/用户/适合应用程序的任何内容隔离此数据。（System.ServiceModel.OperationContext, System.Web.HttpContext, ...，取决于应用程序类型。）

您案例中的上下文数据将设置在当前调用 LoggedInPersonIDInterceptorUtil.Setup 的位置。

如果您需要对需要不同上下文的应用程序使用相同的拦截器实现，那么您需要根据您要添加的一些配置参数选择要使用的上下文（或将其作为依赖项注入到您的拦截器中）。

【讨论】：

这听起来像是一个很有前途的方法！谢谢你的想法，我明天会测试一下，如果可行的话，把它标记为答案:)

【解决方案2】：

依赖注入示例：

DependencyInjectionInterceptor.cs：

using NHibernate;
using System;
using Microsoft.Extensions.DependencyInjection;

namespace MyAmazingApplication
{
    public class DependencyInjectionInterceptor : EmptyInterceptor
    {
        private readonly IServiceProvider _serviceProvider;

        public DependencyInjectionInterceptor(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }

        public T GetService<T>() => _serviceProvider.GetService<T>();

        public T GetRequiredService<T>() => _serviceProvider.GetRequiredService<T>();
    }
}

Startup.cs：

public void ConfigureServices(IServiceCollection services)
{
    ...
    var cfg = new Configuration();
    ... // your config setup
    cfg.SetListeners(NHibernate.Event.ListenerType.PreInsert, new[] { new AuditEventListener() });
    cfg.SetListeners(NHibernate.Event.ListenerType.PreUpdate, new[] { new AuditEventListener() });

    services.AddSingleton(cfg);
    services.AddSingleton(s => s.GetRequiredService<Configuration>().BuildSessionFactory());
    services.AddScoped(s => s.GetRequiredService<ISessionFactory>().WithOptions().Interceptor(new DependencyInjectionInterceptor(s)).OpenSession());

    ... // you other services setup
}

AuditEventListener.cs：

public class AuditEventListener : IPreUpdateEventListener, IPreInsertEventListener
{
    public bool OnPreUpdate(PreUpdateEvent e)
        {
            var user = ((DependencyInjectionInterceptor)e.Session.Interceptor).GetService<ICurrentUser>();

            if (e.Entity is IEntity)
                UpdateAuditTrail(user, e.State, e.Persister.PropertyNames, (IEntity)e.Entity, false);

            return false;
        }
}

所以你使用拦截器来获取你的作用域或任何其他服务： var myService = ((DependencyInjectionInterceptor)e.Session.Interceptor).GetService<IService>();

ICurrentUser 特别是一个范围服务，它使用 HttpContext 来获取当前用户。

希望对大家有帮助。

【讨论】：