提交: 586504c9d8295316ca0a9f9da102c0ff136a48f7 - CleanAuLait48 (git)

Commit MetaInfo

• 修订版: 586504c9d8295316ca0a9f9da102c0ff136a48f7 (tree)
• 时间: 2022-05-26 19:08:06
• 作者: yoshy <yoshy.org.bitbucket@gz.j...>
• Commiter: yoshy

Log Message

[MOD] ハンドラコンテキストファクトリのマップ化により複数のハンドラキューを使い分け可能な機能を実装

更改概述

• modified: Adaptor/Boundary/Controller/IAsyncHandlerContextFactory.cs
• add: Adaptor/Boundary/Controller/IAttachHandlerQueueMap.cs
• modified: Adaptor/Boundary/Controller/IHandlerContextFactory.cs
• add: Adaptor/Controller/AbstractHandlerContextFactoryRegistrar.cs
• modified: Adaptor/Controller/AsyncHandlerContextFactory.cs
• add: Adaptor/Controller/AsyncHandlerContextFactoryRegistrar.cs
• modified: Adaptor/Controller/HandlerContextFactory.cs
• add: Adaptor/Controller/HandlerContextFactoryRegistrar.cs
• modified: Adaptor/Controller/Router/AsyncUseCaseRouter.cs
• modified: Adaptor/Controller/Router/UseCaseRouter.cs
• modified: CleanAuLait48.csproj
• modified: CleanAuLait48ComponentRegisterer.cs

差异

--- a/Adaptor/Boundary/Controller/IAsyncHandlerContextFactory.cs
+++ b/Adaptor/Boundary/Controller/IAsyncHandlerContextFactory.cs
@@ -2,8 +2,9 @@
 
 namespace CleanAuLait48.Adaptor.Boundary.Controller
 {
-    public interface IAsyncHandlerContextFactory
+    public interface IAsyncHandlerContextFactory : IAttachHandlerQueueMap
     {
-        IAsyncHandlerContext Create(IScopedComponentProvider scopedProvider);
+        IAsyncHandlerContext Create(
+                string handlerTypesName, IScopedComponentProvider scopedProvider);
     }
 }
\ No newline at end of file

--- /dev/null
+++ b/Adaptor/Boundary/Controller/IAttachHandlerQueueMap.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CleanAuLait48.Adaptor.Boundary.Controller
+{
+    public interface IAttachHandlerQueueMap
+    {
+        IDictionary<string, IEnumerable<Type>> HandlerQueueMap { get; set; }
+    }
+}

--- a/Adaptor/Boundary/Controller/IHandlerContextFactory.cs
+++ b/Adaptor/Boundary/Controller/IHandlerContextFactory.cs
@@ -2,8 +2,9 @@
 
 namespace CleanAuLait48.Adaptor.Boundary.Controller
 {
-    public interface IHandlerContextFactory
+    public interface IHandlerContextFactory : IAttachHandlerQueueMap
     {
-        IHandlerContext Create(IScopedComponentProvider scopedProvider);
+        IHandlerContext Create(
+                string handlerTypesName, IScopedComponentProvider scopedProvider);
     }
 }
\ No newline at end of file

--- /dev/null
+++ b/Adaptor/Controller/AbstractHandlerContextFactoryRegistrar.cs
@@ -0,0 +1,32 @@
+using CleanAuLait48.Adaptor.Boundary.Controller;
+using CleanAuLait48.Core.DI;
+using System;
+using System.Collections.Generic;
+
+namespace CleanAuLait48.Adaptor.Controller
+{
+    public abstract class AbstractHandlerContextFactoryRegistrar<IFACTORY, FACTORY>
+            where IFACTORY : class, IAttachHandlerQueueMap
+            where FACTORY : IFACTORY, new()
+    {
+        private readonly IDictionary<string, IEnumerable<Type>> map = new Dictionary<string, IEnumerable<Type>>();
+
+        public void Add(string factoryName, IEnumerable<Type> handlerTypes)
+        {
+            map.Add(factoryName, handlerTypes);
+        }
+
+        public void Register(IComponentRegistry registry)
+        {
+            registry.RegisterSingleton(() =>
+            {
+                IFACTORY factory = new FACTORY
+                {
+                    HandlerQueueMap = map
+                };
+
+                return factory;
+            });
+        }
+    }
+}

--- a/Adaptor/Controller/AsyncHandlerContextFactory.cs
+++ b/Adaptor/Controller/AsyncHandlerContextFactory.cs
@@ -2,31 +2,48 @@
 using CleanAuLait48.Adaptor.Boundary.Controller.Handler;
 using CleanAuLait48.Adaptor.Controller.Handler;
 using CleanAuLait48.Core.DI;
+using System;
 using System.Collections.Generic;
 
 namespace CleanAuLait48.Adaptor.Controller
 {
     public class AsyncHandlerContextFactory : IAsyncHandlerContextFactory
     {
-        private readonly IEnumerable<IAsyncRequestHandler> handlers;
+        public IDictionary<string, IEnumerable<Type>> HandlerQueueMap { get; set; }
 
-        public AsyncHandlerContextFactory(IEnumerable<IAsyncRequestHandler> handlers)
+        public IAsyncHandlerContext Create(string handlerQueueName, IScopedComponentProvider scopedProvider)
         {
-            this.handlers = handlers;
+            if (!HandlerQueueMap.TryGetValue(handlerQueueName, out IEnumerable<Type> handlerTypes))
+            {
+                throw new DIException($"Handler Queue [{handlerQueueName}] not registered.");
+            }
+
+            return CreateInternal(scopedProvider, handlerTypes);
+        }
+
+        protected static IAsyncHandlerContext CreateInternal(
+                 IScopedComponentProvider scopedProvider, IEnumerable<Type> handlerTypes)
+        {
+            Queue<IAsyncRequestHandler> queue = CreateHandlerQueue(scopedProvider, handlerTypes);
+
+            IAsyncHandlerContext context = new AsyncHandlerContext(queue, scopedProvider);
+
+            return context;
         }
 
-        public IAsyncHandlerContext Create(IScopedComponentProvider scopedProvider)
+        protected static Queue<IAsyncRequestHandler> CreateHandlerQueue(
+                IScopedComponentProvider scopedProvider, IEnumerable<Type> handlerTypes)
         {
             Queue<IAsyncRequestHandler> queue = new Queue<IAsyncRequestHandler>();
 
-            foreach (IAsyncRequestHandler handler in handlers)
+            foreach (Type handlerType in handlerTypes)
             {
+                IAsyncRequestHandler handler = scopedProvider.Resolve<IAsyncRequestHandler>(handlerType);
+
                 queue.Enqueue(handler);
             }
 
-            IAsyncHandlerContext context = new AsyncHandlerContext(queue, scopedProvider);
-
-            return context;
+            return queue;
         }
     }
 }
\ No newline at end of file

--- /dev/null
+++ b/Adaptor/Controller/AsyncHandlerContextFactoryRegistrar.cs
@@ -0,0 +1,12 @@
+using CleanAuLait48.Adaptor.Boundary.Controller;
+using CleanAuLait48.Core.DI;
+using System;
+using System.Collections.Generic;
+
+namespace CleanAuLait48.Adaptor.Controller
+{
+    public class AsyncHandlerContextFactoryRegistrar : 
+            AbstractHandlerContextFactoryRegistrar<IAsyncHandlerContextFactory, AsyncHandlerContextFactory>
+    {
+    }
+}

--- a/Adaptor/Controller/HandlerContextFactory.cs
+++ b/Adaptor/Controller/HandlerContextFactory.cs
@@ -2,37 +2,48 @@
 using CleanAuLait48.Adaptor.Boundary.Controller.Handler;
 using CleanAuLait48.Adaptor.Controller.Handler;
 using CleanAuLait48.Core.DI;
+using System;
 using System.Collections.Generic;
 
 namespace CleanAuLait48.Adaptor.Controller
 {
     public class HandlerContextFactory : IHandlerContextFactory
     {
-        private readonly IEnumerable<IRequestHandler> handlers;
+        public IDictionary<string, IEnumerable<Type>> HandlerQueueMap { get; set; }
 
-        public HandlerContextFactory(IEnumerable<IRequestHandler> handlers)
+        public IHandlerContext Create(string handlerQueueName, IScopedComponentProvider scopedProvider)
         {
-            this.handlers = handlers;
+            if (!HandlerQueueMap.TryGetValue(handlerQueueName, out IEnumerable<Type> handlerTypes))
+            {
+                throw new DIException($"Handler Queue [{handlerQueueName}] not registered.");
+            }
+
+            return CreateInternal(scopedProvider, handlerTypes);
         }
 
-        public IHandlerContext Create(IScopedComponentProvider scopedProvider)
+        protected static IHandlerContext CreateInternal(
+                IScopedComponentProvider scopedProvider, IEnumerable<Type> handlerTypes)
         {
-            return CreateInternal(scopedProvider, this.handlers);
+            Queue<IRequestHandler> queue = CreateHandlerQueue(scopedProvider, handlerTypes);
+
+            IHandlerContext context = new HandlerContext(queue, scopedProvider);
+
+            return context;
         }
 
-        protected static IHandlerContext CreateInternal(
-                IScopedComponentProvider scopedProvider, IEnumerable<IRequestHandler> handlers)
+        protected static Queue<IRequestHandler> CreateHandlerQueue(
+                IScopedComponentProvider scopedProvider, IEnumerable<Type> handlerTypes)
         {
             Queue<IRequestHandler> queue = new Queue<IRequestHandler>();
 
-            foreach (IRequestHandler handler in handlers)
+            foreach (Type handlerType in handlerTypes)
             {
+                IRequestHandler handler = scopedProvider.Resolve<IRequestHandler>(handlerType);
+
                 queue.Enqueue(handler);
             }
 
-            IHandlerContext context = new HandlerContext(queue, scopedProvider);
-
-            return context;
+            return queue;
         }
     }
 }
\ No newline at end of file

--- /dev/null
+++ b/Adaptor/Controller/HandlerContextFactoryRegistrar.cs
@@ -0,0 +1,12 @@
+using CleanAuLait48.Adaptor.Boundary.Controller;
+using CleanAuLait48.Core.DI;
+using System;
+using System.Collections.Generic;
+
+namespace CleanAuLait48.Adaptor.Controller
+{
+    public class HandlerContextFactoryRegistrar : 
+            AbstractHandlerContextFactoryRegistrar<IHandlerContextFactory, HandlerContextFactory>
+    {
+    }
+}

--- a/Adaptor/Controller/Router/AsyncUseCaseRouter.cs
+++ b/Adaptor/Controller/Router/AsyncUseCaseRouter.cs
@@ -13,13 +13,6 @@ namespace CleanAuLait48.Adaptor.Controller.Router
     {
         private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
 
-        private readonly IAsyncRequestScopeGenerator scopeGenerator;
-
-        public AsyncUseCaseRouter(IAsyncRequestScopeGenerator scopeGenerator)
-        {
-            this.scopeGenerator = scopeGenerator;
-        }
-
         public async Task<UseCaseResponse> HandleAsync(UseCaseRequest req, IAsyncHandlerContext context)
         {
             try
@@ -28,7 +21,6 @@ namespace CleanAuLait48.Adaptor.Controller.Router
 
                 IAsyncUseCaseRouterAwareInteractor asyncInteractor = GetComponent(context.ScopedProvider, req);
 
-                // routing map is null, or request type key not registered on routing map.
                 if (asyncInteractor == null)
                 {
                     logger.Error("get async interactor instance failed.");
@@ -45,7 +37,6 @@ namespace CleanAuLait48.Adaptor.Controller.Router
             }
             catch (DIException e)
             {
-                // component concrete instance not registered on di container.
                 string msg = "コンポーネントがDIコンテナに登録されていません";
                 throw new ApplicationException(msg, e);
             }

--- a/Adaptor/Controller/Router/UseCaseRouter.cs
+++ b/Adaptor/Controller/Router/UseCaseRouter.cs
@@ -12,13 +12,6 @@ namespace CleanAuLait48.Adaptor.Controller.Router
     {
         private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
 
-        private readonly IRequestScopeGenerator scopeGenerator;
-
-        public UseCaseRouter(IRequestScopeGenerator scopeGenerator)
-        {
-            this.scopeGenerator = scopeGenerator;
-        }
-
         public UseCaseResponse Handle(UseCaseRequest req, IHandlerContext context)
         {
             try

--- a/CleanAuLait48.csproj
+++ b/CleanAuLait48.csproj
@@ -54,6 +54,10 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Adaptor\Boundary\Controller\IAttachHandlerQueueMap.cs" />
+    <Compile Include="Adaptor\Controller\AbstractHandlerContextFactoryRegistrar.cs" />
+    <Compile Include="Adaptor\Controller\AsyncHandlerContextFactoryRegistrar.cs" />
+    <Compile Include="Adaptor\Controller\HandlerContextFactoryRegistrar.cs" />
     <Compile Include="CleanAuLait48ComponentRegisterer.cs" />
     <Compile Include="Adaptor\Boundary\Controller\Handler\IAsyncRequestHandler.cs" />
     <Compile Include="Adaptor\Boundary\Controller\Handler\IRequestHandler.cs" />

--- a/CleanAuLait48ComponentRegisterer.cs
+++ b/CleanAuLait48ComponentRegisterer.cs
@@ -34,9 +34,6 @@ namespace CleanAuLait48
             componentRegistry.RegisterSingleton<IRequestScopeGenerator, RequestScopeGenerator>();
             componentRegistry.RegisterSingleton<IAsyncRequestScopeGenerator, AsyncRequestScopeGenerator>();
 
-            componentRegistry.RegisterSingleton<IHandlerContextFactory, HandlerContextFactory>();
-            componentRegistry.RegisterSingleton<IAsyncHandlerContextFactory, AsyncHandlerContextFactory>();
-
             logger.Trace("RegisterTypes end");
         }