Castle WindsorおよびNHibernateを使用した依存関係の注入と作業単位の実装

この記事では、Castle WindsorをDIコンテナとして使用し、NHibernateをオブジェクトリレーショナルマッピング（ORM）ツールとして使用して、依存性注入、リポジトリ、および作業単位の実装を示します。



→ ソースコードのダウンロード-962 Kb

依存性注入は、ハードコーディングされた依存関係を削除したり、実行時およびコンパイル時にそれらを変更したりできるソフトウェア開発パターンです[1] 。
リポジトリは、ドメインとデータ表示層の間の中間体であり、特別なインターフェースを使用してドメインオブジェクトにアクセスします[2] 。
作業ユニットは、アプリケーションのトランザクション機能を定義および管理するために使用されるパターンです[4] 。

エンティティと作業ユニットの紹介については、多くの記事、レッスン、およびその他のリソースがありますので、それらについては定義しません。 この記事は、後で説明する困難を解決することに専念しています。

難しさ

データ駆動型アプリケーションの開発は、いくつかの原則に従う必要があります。 私が話したいのは、これらの原則についてです。

接続を開閉する方法

もちろん、接続はデータベースレベル（リポジトリ内）で最適に管理されます。 たとえば、リポジトリメソッドへのすべての呼び出しで、接続を開き、データベースでコマンドを実行し、接続を閉じることができます。 しかし、同じリポジトリ内の異なるメソッドまたは異なるリポジトリの異なるメソッドに同じ接続を使用する必要がある場合、このオプションは非効率になります（異なるリポジトリのメソッドを使用するトランザクションを考えてください）。

（ASP.NET MVCまたはWebフォームを使用して）サイトを作成するとき、Application_BeginRequestを使用して接続を開き、Application_EndRequestを使用して接続を閉じることができます。 しかし、このアプローチには欠点があります。

• すべてのリクエストがデータベースを使用しているわけではない場合でも、データベースはリクエストごとに開閉されます。 接続が使用されていない場合でも、接続はプールから取得されることがわかります。
• データベースはクエリの最初に開き、最後に閉じます。 ただし、要求が長すぎる場合があり、データベース操作にかかる時間がわずかであるため、接続プールの使用が非効率的になります。

上記の困難はあなたにはささいなことかもしれませんが、私にとっては大きな問題です。 しかし、サイトを開発せず、しばらくの間データベースを使用する多くのスレッドを起動するWindowsサービスを開発したらどうでしょうか。 この場合、どこで接続を開いたり閉じたりしますか？

トランザクションを管理する方法

アプリケーション（ほとんどのアプリケーションと同様）がデータベースを操作するときにトランザクションを使用する場合、この場合、トランザクションをどこで開始、コミット、またはロールバックする必要がありますか？ リポジトリメソッドでこれを行うことはできません。トランザクションには、リポジトリメソッドへのさまざまな呼び出しを含めることができます。 したがって、これらの操作はすべてドメインレイヤーで実行できます。 しかし、このアプローチには欠点もあります。

• ドメイン層には、データベース固有のコードが含まれていますが、これは単一の義務とマルチレベル表現の使用の原則に違反しています。
• このアプローチは、ドメインレイヤーの各メソッドのトランザクションロジックを複製します。

上で述べたように、Application_BeginRequestとApplication_EndRequestを使用してトランザクションを管理できます。 ここでも同じ問題が発生します。不要なトランザクションを開始またはコミットします。 さらに、エラーを修正した後、それらの一部をロールバックする必要があります。

Webサイトではなくアプリケーションを開発している場合、トランザクションを開始、コミット、およびロールバックする適切な場所を見つけるのは簡単ではありません。

したがって、本当に必要なときにトランザクションを開始し、すべての操作が成功した場合に記録し、いずれかの操作が失敗した場合にのみロールバックするのが最善です。 この原則に基づいて、私はさらに指導されます。

実装

私のアプリケーションは、ASP.NET MVC（Webフレームワークとして）、SQL Server（DBMSとして）、NHibernate（ORMとして）、Castle Windsor（依存性注入コンテナーとして）を使用して作成された電話帳です。

エンティティ

私の実装では、エンティティはデータベース内のテーブルエントリに変換されます。 オブジェクト指向設計のエンティティは、 一意の識別子を持つ永続オブジェクトです。 この場合、すべてのエンティティは以下のEntityクラスから派生します。

public interface IEntity<TPrimaryKey> { TPrimaryKey Id { get; set; } } public class Entity<TPrimaryKey> : IEntity<TPrimaryKey> { public virtual TPrimaryKey Id { get; set; } } 

エンティティには一意の識別子があります。これは主キーであり、異なるタイプ（int、long、guidなど）を持つことができます。 したがって、我々はジェネリッククラスを扱っており、People、Phone、Cityなどのエンティティはそこから派生しています。 Peopleクラスの定義は次のようになります。

 public class Person : Entity<int> { public virtual int CityId { get; set; } public virtual string Name { get; set; } public virtual DateTime BirthDay { get; set; } public virtual string Notes { get; set; } public virtual DateTime RecordDate { get; set; } public Person() { Notes = ""; RecordDate = DateTime.Now; } } 

ご覧のとおり、Personの主キーはintとして定義されています。

エンティティ変換

EntityやNHibernateフレームワークなどのオブジェクトリレーショナルマッピングツールでは、エンティティをデータベーステーブルに変換する定義が必要です。 これを実装するには多くの方法があります。 たとえば、NHibernate Fluent APIを使用しました。 以下のPeopleエンティティの例に示すように、すべてのエンティティの変換クラスを定義する必要があります。

 public class PersonMap : ClassMap<Person> { public PersonMap() { Table("People"); Id(x => x.Id).Column("PersonId"); Map(x => x.CityId); Map(x => x.Name); Map(x => x.BirthDay); Map(x => x.Notes); Map(x => x.RecordDate); 

リポジトリ（DBレベル）

リポジトリを使用してデータベースレベルを作成し、データアクセスのロジックを上位レベルから分離します。 リポジトリクラスは通常、エンティティまたは集約（エンティティのグループ）ごとに作成されます。 エンティティごとにリポジトリを作成しました。 最初に、すべてのリポジトリクラスによって実装される必要があるインターフェイスを定義しました。

 /// <summary> /// This interface must be implemented by all repositories to ensure UnitOfWork to work. /// </summary> public interface IRepository { } /// <summary> /// This interface is implemented by all repositories to ensure implementation of fixed methods. /// </summary> /// <typeparam name="TEntity">Main Entity type this repository works on</typeparam> /// <typeparam name="TPrimaryKey">Primary key type of the entity</typeparam> public interface IRepository<TEntity, TPrimaryKey> : IRepository where TEntity : Entity<TPrimaryKey> { /// <summary> /// Used to get a IQueryable that is used to retrive entities from entire table. /// </summary> /// <returns>IQueryable to be used to select entities from database</returns> IQueryable<TEntity> GetAll(); /// <summary> /// Gets an entity. /// </summary> /// <param name="key">Primary key of the entity to get</param> /// <returns>Entity</returns> TEntity Get(TPrimaryKey key); /// <summary> /// Inserts a new entity. /// </summary> /// <param name="entity">Entity</param> void Insert(TEntity entity); /// <summary> /// Updates an existing entity. /// </summary> /// <param name="entity">Entity</param> void Update(TEntity entity); /// <summary> /// Deletes an entity. /// </summary> /// <param name="id">Id of the entity</param> void Delete(TPrimaryKey id); } 

したがって、すべてのリポジトリクラスは上記のメソッドを実装する必要があります。 ただし、NHibernateには、これらのメソッドの実装がほぼ同じです。 同じロジックをすべてのリポジトリに適用せずに、すべてのリポジトリの基本クラスを定義できることがわかりました。 NhRepositoryBaseの定義は次のとおりです。

 /// <summary> /// Base class for all repositories those uses NHibernate. /// </summary> /// <typeparam name="TEntity">Entity type</typeparam> /// <typeparam name="TPrimaryKey">Primary key type of the entity</typeparam> public abstract class NhRepositoryBase<TEntity, TPrimaryKey> : IRepository<TEntity, TPrimaryKey> where TEntity : Entity<TPrimaryKey> { /// <summary> /// Gets the NHibernate session object to perform database operations. /// </summary> protected ISession Session { get { return NhUnitOfWork.Current.Session; } } /// <summary> /// Used to get a IQueryable that is used to retrive object from entire table. /// </summary> /// <returns>IQueryable to be used to select entities from database</returns> public IQueryable<TEntity> GetAll() { return Session.Query<TEntity>(); } /// <summary> /// Gets an entity. /// </summary> /// <param name="key">Primary key of the entity to get</param> /// <returns>Entity</returns> public TEntity Get(TPrimaryKey key) { return Session.Get<TEntity>(key); } /// <summary> /// Inserts a new entity. /// </summary> /// <param name="entity">Entity</param> public void Insert(TEntity entity) { Session.Save(entity); } /// <summary> /// Updates an existing entity. /// </summary> /// <param name="entity">Entity</param> public void Update(TEntity entity) { Session.Update(entity); } /// <summary> /// Deletes an entity. /// </summary> /// <param name="id">Id of the entity</param> public void Delete(TPrimaryKey id) { Session.Delete(Session.Load<TEntity>(id)); } } 

セッションプロパティは、現在のトランザクションの正しいSessionオブジェクトを受け取るNhUnitOfWork.Current.Sessionからセッションオブジェクト（NHibernateのデータベース接続オブジェクト）を取得するために使用されます。 したがって、接続またはトランザクションを開いたり閉じたりする方法を決定する必要はありません。 さらに、このメカニズムの説明について詳しく説明します。

すべてのリポジトリに対して、すべてのCRUD操作がデフォルトで実装されています。 これで、エントリを選択、更新、削除できるPersonRepositoryを作成できます。 これを行うには、次のように2つの型を宣言します。

 public interface IPersonRepository : IRepository<Person, int> { } public class NhPersonRepository : NhRepositoryBase<Person, int>, IPersonRepository { } 

同じことがPhoneおよびCityエンティティに対しても実行できます。 特別なリポジトリメソッドを追加する必要がある場合、対応するエンティティのリポジトリでこれを行うことができます。 たとえば、特定の人の電話を削除できるように、PhoneRepositoryに新しいメソッドを追加します。

 public interface IPhoneRepository : IRepository<Phone, int> { /// <summary> /// Deletes all phone numbers for given person id. /// </summary> /// <param name="personId">Id of the person</param> void DeletePhonesOfPerson(int personId); } public class NhPhoneRepository : NhRepositoryBase<Phone, int>, IPhoneRepository { public void DeletePhonesOfPerson(int personId) { var phones = GetAll().Where(phone => phone.PersonId == personId).ToList(); foreach (var phone in phones) { Session.Delete(phone); } } } 

作業単位

作業単位は、アプリケーションのトランザクション機能を定義および管理するために使用されます。 まず、IUnitOfWorkインターフェースを定義する必要があります。

 /// <summary> /// Represents a transactional job. /// </summary> public interface IUnitOfWork { /// <summary> /// Opens database connection and begins transaction. /// </summary> void BeginTransaction(); /// <summary> /// Commits transaction and closes database connection. /// </summary> void Commit(); /// <summary> /// Rollbacks transaction and closes database connection. /// </summary> void Rollback(); } 

NHibernateのIUnitOfWorkの実装を以下に示します。

 /// <summary> /// Implements Unit of work for NHibernate. /// </summary> public class NhUnitOfWork : IUnitOfWork { /// <summary> /// Gets current instance of the NhUnitOfWork. /// It gets the right instance that is related to current thread. /// </summary> public static NhUnitOfWork Current { get { return _current; } set { _current = value; } } [ThreadStatic] private static NhUnitOfWork _current; /// <summary> /// Gets Nhibernate session object to perform queries. /// </summary> public ISession Session { get; private set; } /// <summary> /// Reference to the session factory. /// </summary> private readonly ISessionFactory _sessionFactory; /// <summary> /// Reference to the currently running transcation. /// </summary> private ITransaction _transaction; /// <summary> /// Creates a new instance of NhUnitOfWork. /// </summary> /// <param name="sessionFactory"></param> public NhUnitOfWork(ISessionFactory sessionFactory) { _sessionFactory = sessionFactory; } /// <summary> /// Opens database connection and begins transaction. /// </summary> public void BeginTransaction() { Session = _sessionFactory.OpenSession(); _transaction = Session.BeginTransaction(); } /// <summary> /// Commits transaction and closes database connection. /// </summary> public void Commit() { try { _transaction.Commit(); } finally { Session.Close(); } } /// <summary> /// Rollbacks transaction and closes database connection. /// </summary> public void Rollback() { try { _transaction.Rollback(); } finally { Session.Close(); } } } 

静的プロパティCurrentは、クラス全体にとって重要です。 ThreadStaticとしてマークされた_currentフィールドを受け取り、構成します。 そうすれば、同じスレッドで同じ作業単位オブジェクトを使用できます。 これは、複数のオブジェクトが同じ接続またはトランザクションを共有できることを意味します。 最後に、メソッドをマークするために使用される属性を定義します。これはトランザクション型である必要があります。

 /// <summary> /// This attribute is used to indicate that declaring method is transactional (atomic). /// A method that has this attribute is intercepted, a transaction starts before call the method. /// At the end of method call, transaction is commited if there is no exception, othervise it's rolled back. /// </summary> [AttributeUsage(AttributeTargets.Method)] public class UnitOfWorkAttribute : Attribute { } 

特定のメソッドがトランザクション型である場合、UnitOfWork属性でマークする必要があります。 次に、以下に示すように、依存性注入を使用してこれらのメソッドをインターセプトします。

サービスレベル

ドメイン固有の設計では、ドメインサービスを使用してドメインロジックを実装し、リポジトリを使用してデータベースタスクを実行できます。 たとえば、PersonServiceの定義は次のようになります。

 public class PersonService : IPersonService { private readonly IPersonRepository _personRepository; private readonly IPhoneRepository _phoneRepository; public PersonService(IPersonRepository personRepository, IPhoneRepository phoneRepository) { _personRepository = personRepository; _phoneRepository = phoneRepository; } public void CreatePerson(Person person) { _personRepository.Insert(person); } [UnitOfWork] public void DeletePerson(int personId) { _personRepository.Delete(personId); _phoneRepository.DeletePhonesOfPerson(personId); } //... some other methods are not shown here since it's not needed. See source codes. } 

上記で定義したUnitOfWork属性の使用に注意してください。 DeletePersonメソッドはUnitOfWorkとしてマークされます。 2つの異なるリポジトリメソッドを呼び出し、これらのメソッド呼び出しはトランザクションである必要があります。 一方、CreatePersonメソッドはUnitOfWorkとしてマークされません。これは、独自のトランザクションを管理できる個人リポジトリ用のInsertメソッドを1つだけ呼び出すためです。 さらに、これがどのように実装されるかを見ていきます。

依存性注入（DI）

Castle WindsorなどのDIコンテナは、アプリケーションオブジェクトの依存関係とライフサイクルを管理するために使用されます。 これにより、疎結合のコンポーネントとモジュールをアプリケーションに作成できます。 ASP.NETアプリケーションでは、通常、DIコンテナはglobal.asaxファイルで初期化されます。 これは通常、起動時に発生します。

 public class MvcApplication : System.Web.HttpApplication { private WindsorContainer _windsorContainer; protected void Application_Start() { InitializeWindsor(); // Other startup logic... } protected void Application_End() { if (_windsorContainer != null) { _windsorContainer.Dispose(); } } private void InitializeWindsor() { _windsorContainer = new WindsorContainer(); _windsorContainer.Install(FromAssembly.This()); ControllerBuilder.Current.SetControllerFactory(new WindsorControllerFactory(_windsorContainer.Kernel)); } } 

WindsowContainerオブジェクトは、依存関係を実装するときに重要であり、アプリケーションの起動時に作成され、最後に削除されます。 依存関係を実装するには、InitializeWindsorメソッドでMVCコントローラーファクトリのデフォルト設定も変更する必要があります。 ASP.NETのMVCパターンが（すべてのWeb要求で）コントローラーを必要とするときはいつでも、 依存性注入を使用して作成します。 キャッスルウィンザーの詳細については、 こちらをご覧ください 。 コントローラファクトリは次のようになります。

 public class WindsorControllerFactory : DefaultControllerFactory { private readonly IKernel _kernel; public WindsorControllerFactory(IKernel kernel) { _kernel = kernel; } public override void ReleaseController(IController controller) { _kernel.ReleaseComponent(controller); } protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType) { if (controllerType == null) { throw new HttpException(404, string.Format("The controller for path '{0}' could not be found.", requestContext.HttpContext.Request.Path)); } return (IController)_kernel.Resolve(controllerType); } } 

一見しただけでも非常にシンプルで理解しやすいものです。 PhoneBookDependencyInstallerクラスを使用して、独自のオブジェクト依存関係を埋め込む必要があります。 Castle Windsorは、IWindsorInstallerの実装により、このクラスを自動的に検出します。 行_windsorContainer.Install（FromAssembly.This（））;を覚えておいてください。 global.asaxファイル内。

 public class PhoneBookDependencyInstaller : IWindsorInstaller { public void Install(IWindsorContainer container, IConfigurationStore store) { container.Kernel.ComponentRegistered += Kernel_ComponentRegistered; //Register all controllers container.Register( //Nhibernate session factory Component.For<ISessionFactory>().UsingFactoryMethod(CreateNhSessionFactory).LifeStyle.Singleton, //Unitofwork interceptor Component.For<NhUnitOfWorkInterceptor>().LifeStyle.Transient, //All repoistories Classes.FromAssembly(Assembly.GetAssembly(typeof(NhPersonRepository))).InSameNamespaceAs<NhPersonRepository>().WithService.DefaultInterfaces().LifestyleTransient(), //All services Classes.FromAssembly(Assembly.GetAssembly(typeof(PersonService))).InSameNamespaceAs<PersonService>().WithService.DefaultInterfaces().LifestyleTransient(), //All MVC controllers Classes.FromThisAssembly().BasedOn<IController>().LifestyleTransient() ); } /// <summary> /// Creates NHibernate Session Factory. /// </summary> /// <returns>NHibernate Session Factory</returns> private static ISessionFactory CreateNhSessionFactory() { var connStr = ConfigurationManager.ConnectionStrings["PhoneBook"].ConnectionString; return Fluently.Configure() .Database(MsSqlConfiguration.MsSql2008.ConnectionString(connStr)) .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetAssembly(typeof(PersonMap)))) .BuildSessionFactory(); } void Kernel_ComponentRegistered(string key, Castle.MicroKernel.IHandler handler) { //Intercept all methods of all repositories. if (UnitOfWorkHelper.IsRepositoryClass(handler.ComponentModel.Implementation)) { handler.ComponentModel.Interceptors.Add(new InterceptorReference(typeof(NhUnitOfWorkInterceptor))); } //Intercept all methods of classes those have at least one method that has UnitOfWork attribute. foreach (var method in handler.ComponentModel.Implementation.GetMethods()) { if (UnitOfWorkHelper.HasUnitOfWorkAttribute(method)) { handler.ComponentModel.Interceptors.Add(new InterceptorReference(typeof(NhUnitOfWorkInterceptor))); return; } } } } 

ご覧のとおり、Castle WindsorのRegisterメソッドを使用してすべてのコンポーネントを登録しています。 注：すべてのリポジトリクラスは1行で登録されます。 サービスとコントローラーについても同じことが必要です。 ファクトリメソッドを使用して、NHibernateで使用するISessionオブジェクト（データベース接続）を作成するISessionFactoryファクトリを作成します。 Installメソッドの開始時に、ComponentRegisteredイベントをログに記録してインターセプトロジックを実装します。 Kernel_ComponentRegisteredを見てください。 メソッドがリポジトリメソッドである場合、常にインターセプトを使用します。 さらに、メソッドがUnitOfWork属性でマークされている場合、NhUnitOfWorkInterceptorクラスによってもインターセプトされます。

傍受

インターセプトは、メソッド呼び出しの開始時と終了時にいくつかのコードを実行できる特別な手法です。 通常、インターセプトはロギング、プロファイリング、キャッシュなどに使用されます。 メソッド自体を変更せずに、必要なメソッドにコードを動的に埋め込むことができます。

この場合、インターセプトは作業ユニットの実装に役立ちます。 特定のメソッドがリポジトリメソッドであるか、UnitOfWork属性としてマークされている場合（上記を参照）、データベースと（NHibernateのセッション）への接続を開き、メソッドの開始時にトランザクションを開始します。 インターセプトされたメソッドが単一の例外をスローしない場合、トランザクションはメソッドの最後にコミットされます。 メソッドが例外をスローすると、トランザクション全体がロールバックされます。 NhUnitOfWorkInterceptorクラスの実装を見てみましょう。

 /// <summary> /// This interceptor is used to manage transactions. /// </summary> public class NhUnitOfWorkInterceptor : IInterceptor { private readonly ISessionFactory _sessionFactory; /// <summary> /// Creates a new NhUnitOfWorkInterceptor object. /// </summary> /// <param name="sessionFactory">Nhibernate session factory.</param> public NhUnitOfWorkInterceptor(ISessionFactory sessionFactory) { _sessionFactory = sessionFactory; } /// <summary> /// Intercepts a method. /// </summary> /// <param name="invocation">Method invocation arguments</param> public void Intercept(IInvocation invocation) { //If there is a running transaction, just run the method if (NhUnitOfWork.Current != null || !RequiresDbConnection(invocation.MethodInvocationTarget)) { invocation.Proceed(); return; } try { NhUnitOfWork.Current = new NhUnitOfWork(_sessionFactory); NhUnitOfWork.Current.BeginTransaction(); try { invocation.Proceed(); NhUnitOfWork.Current.Commit(); } catch { try { NhUnitOfWork.Current.Rollback(); } catch { } throw; } } finally { NhUnitOfWork.Current = null; } } private static bool RequiresDbConnection(MethodInfo methodInfo) { if (UnitOfWorkHelper.HasUnitOfWorkAttribute(methodInfo)) { return true; } if (UnitOfWorkHelper.IsRepositoryMethod(methodInfo)) { return true; } return false; } } 

インターセプトが主な方法です。 まず、特定のスレッドに対して以前に実行されていたトランザクションが存在するかどうかを確認します。 その場合、新しいトランザクションは開始されませんが、現在のトランザクションが使用されます（NhUnitOfWork.Currentを参照）。 したがって、UnitOfWork属性を持つネストされたメソッド呼び出しは、同じトランザクションを共有できます。 トランザクションは、作業単位メソッドを初めて使用するときにのみ作成またはコミットされます。 さらに、メソッドがトランザクションに対応していない場合、メソッドを呼び出して戻ります。 invocation.Proceed（）コマンドは、インターセプトされたメソッドを呼び出します。

現在のトランザクションがない場合は、新しいトランザクションを開始し、エラーがない場合はコミットする必要があります。 それ以外の場合は、ロールバックします。 その後、NhUnitOfWork.Current = nullを設定して、後で必要に応じてこのストリームの他のトランザクションを開始できるようにします。 UnitOfWorkHelperクラスもご覧ください。

したがって、接続を開いたり閉じたり、トランザクションを開始、コミット、およびロールバックしたりするためのコードは、アプリケーションの1つのポイントでのみ定義されます。