コミット: 9a78b11a152465e143c6f339759b754e8b15e604 - CleanAuLait (git)

コミットメタ情報

• リビジョン: 9a78b11a152465e143c6f339759b754e8b15e604 (tree)
• 日時: 2022-05-26 19:07:40
• 作者: yoshy <yoshy.org.bitbucket@gz.j...>
• コミッター: yoshy

ログメッセージ

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

変更サマリ

• modified: Adaptor/Boundary/Controller/IAsyncHandlerContext.cs
• modified: Adaptor/Boundary/Controller/IAsyncHandlerContextFactory.cs
• add: Adaptor/Boundary/Controller/IAttachHandlerQueueMap.cs
• modified: Adaptor/Boundary/Controller/IHandlerContext.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/Handler/AsyncHandlerContext.cs
• modified: Adaptor/Controller/Handler/HandlerContext.cs
• modified: Adaptor/Controller/HandlerContextFactory.cs
• add: Adaptor/Controller/HandlerContextFactoryRegistrar.cs
• modified: Adaptor/Controller/Router/AbstractUseCaseRouter.cs
• modified: Adaptor/Controller/Router/AsyncUseCaseRouter.cs
• modified: Adaptor/Controller/Router/UseCaseRouter.cs
• modified: CleanAuLaitModule.cs

差分

--- a/Adaptor/Boundary/Controller/IAsyncHandlerContext.cs
+++ b/Adaptor/Boundary/Controller/IAsyncHandlerContext.cs
@@ -9,7 +9,7 @@ namespace CleanAuLait.Adaptor.Boundary.Controller
     {
         Queue<IAsyncRequestHandler> HandlerQueue { get; }
 
-        IScopedProvider Scope { get; }
+        IScopedProvider ScopedProvider { get; }
 
         Task<UseCaseResponse> HandleNextAsync(UseCaseRequest req, IAsyncHandlerContext context);
     }

--- a/Adaptor/Boundary/Controller/IAsyncHandlerContextFactory.cs
+++ b/Adaptor/Boundary/Controller/IAsyncHandlerContextFactory.cs
@@ -2,8 +2,9 @@
 
 namespace CleanAuLait.Adaptor.Boundary.Controller
 {
-    public interface IAsyncHandlerContextFactory
+    public interface IAsyncHandlerContextFactory : IAttachHandlerQueueMap
     {
-        IAsyncHandlerContext Create(IScopedProvider scope);
+        IAsyncHandlerContext Create(
+                string handlerTypesName,IScopedProvider 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 CleanAuLait.Adaptor.Boundary.Controller
+{
+    public interface IAttachHandlerQueueMap
+    {
+        IDictionary<string, IEnumerable<Type>> HandlerQueueMap { get; set; }
+    }
+}

--- a/Adaptor/Boundary/Controller/IHandlerContext.cs
+++ b/Adaptor/Boundary/Controller/IHandlerContext.cs
@@ -9,7 +9,7 @@ namespace CleanAuLait.Adaptor.Boundary.Controller
     {
         Queue<IRequestHandler> HandlerQueue { get; }
 
-        IScopedProvider Scope { get; }
+        IScopedProvider ScopedProvider { get; }
 
         UseCaseResponse HandleNext(UseCaseRequest req, IHandlerContext context);
     }

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

--- /dev/null
+++ b/Adaptor/Controller/AbstractHandlerContextFactoryRegistrar.cs
@@ -0,0 +1,30 @@
+using CleanAuLait.Adaptor.Boundary.Controller;
+using Prism.Ioc;
+
+namespace CleanAuLait.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(IContainerRegistry registry)
+        {
+            registry.RegisterSingleton<IFACTORY>(() =>
+            {
+                IFACTORY factory = new FACTORY
+                {
+                    HandlerQueueMap = map
+                };
+
+                return factory;
+            });
+        }
+    }
+}

--- a/Adaptor/Controller/AsyncHandlerContextFactory.cs
+++ b/Adaptor/Controller/AsyncHandlerContextFactory.cs
@@ -1,31 +1,48 @@
 using CleanAuLait.Adaptor.Boundary.Controller;
 using CleanAuLait.Adaptor.Boundary.Controller.Handler;
 using CleanAuLait.Adaptor.Controller.Handler;
+using CleanAuLait.Core.DI;
 using Prism.Ioc;
 
 namespace CleanAuLait.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, IScopedProvider 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(
+                 IScopedProvider scopedProvider, IEnumerable<Type> handlerTypes)
+        {
+            Queue<IAsyncRequestHandler> queue = CreateHandlerQueue(scopedProvider, handlerTypes);
+
+            IAsyncHandlerContext context = new AsyncHandlerContext(queue, scopedProvider);
+
+            return context;
         }
 
-        public IAsyncHandlerContext Create(IScopedProvider scope)
+        protected static Queue<IAsyncRequestHandler> CreateHandlerQueue(
+                IScopedProvider scopedProvider, IEnumerable<Type> handlerTypes)
         {
             Queue<IAsyncRequestHandler> queue = new();
 
-            foreach (IAsyncRequestHandler handler in handlers)
+            foreach (Type handlerType in handlerTypes)
             {
+                IAsyncRequestHandler handler = (IAsyncRequestHandler)scopedProvider.Resolve(handlerType);
+
                 queue.Enqueue(handler);
             }
 
-            IAsyncHandlerContext context = new AsyncHandlerContext(queue, scope);
-
-            return context;
+            return queue;
         }
     }
 }
\ No newline at end of file

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

--- a/Adaptor/Controller/Handler/AsyncHandlerContext.cs
+++ b/Adaptor/Controller/Handler/AsyncHandlerContext.cs
@@ -9,12 +9,12 @@ namespace CleanAuLait.Adaptor.Controller.Handler
     public class AsyncHandlerContext : IAsyncHandlerContext
     {
         public Queue<IAsyncRequestHandler> HandlerQueue { get; }
-        public IScopedProvider Scope { get; }
+        public IScopedProvider ScopedProvider { get; }
 
-        public AsyncHandlerContext(Queue<IAsyncRequestHandler> queue, IScopedProvider scope)
+        public AsyncHandlerContext(Queue<IAsyncRequestHandler> queue, IScopedProvider scopedProvider)
         {
             this.HandlerQueue = queue;
-            this.Scope = scope;
+            this.ScopedProvider = scopedProvider;
         }
 
         public async Task<UseCaseResponse> HandleNextAsync(UseCaseRequest req, IAsyncHandlerContext context)

--- a/Adaptor/Controller/Handler/HandlerContext.cs
+++ b/Adaptor/Controller/Handler/HandlerContext.cs
@@ -9,12 +9,12 @@ namespace CleanAuLait.Adaptor.Controller.Handler
     public class HandlerContext : IHandlerContext
     {
         public Queue<IRequestHandler> HandlerQueue { get; }
-        public IScopedProvider Scope { get; }
+        public IScopedProvider ScopedProvider { get; }
 
-        public HandlerContext(Queue<IRequestHandler> queue, IScopedProvider scope)
+        public HandlerContext(Queue<IRequestHandler> queue, IScopedProvider scopedProvider)
         {
             this.HandlerQueue = queue;
-            this.Scope = scope;
+            this.ScopedProvider = scopedProvider;
         }
 
         public UseCaseResponse HandleNext(UseCaseRequest req, IHandlerContext context)

--- a/Adaptor/Controller/HandlerContextFactory.cs
+++ b/Adaptor/Controller/HandlerContextFactory.cs
@@ -1,31 +1,48 @@
 using CleanAuLait.Adaptor.Boundary.Controller;
 using CleanAuLait.Adaptor.Boundary.Controller.Handler;
 using CleanAuLait.Adaptor.Controller.Handler;
+using CleanAuLait.Core.DI;
 using Prism.Ioc;
 
 namespace CleanAuLait.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, IScopedProvider 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 IHandlerContext CreateInternal(
+                IScopedProvider scopedProvider, IEnumerable<Type> handlerTypes)
+        {
+            Queue<IRequestHandler> queue = CreateHandlerQueue(scopedProvider, handlerTypes);
+
+            IHandlerContext context = new HandlerContext(queue, scopedProvider);
+
+            return context;
         }
 
-        public IHandlerContext Create(IScopedProvider scope)
+        protected static Queue<IRequestHandler> CreateHandlerQueue(
+                IScopedProvider scopedProvider, IEnumerable<Type> handlerTypes)
         {
             Queue<IRequestHandler> queue = new();
 
-            foreach (IRequestHandler handler in handlers)
+            foreach (Type handlerType in handlerTypes)
             {
+                IRequestHandler handler = (IRequestHandler)scopedProvider.Resolve(handlerType);
+
                 queue.Enqueue(handler);
             }
 
-            IHandlerContext context = new HandlerContext(queue, scope);
-
-            return context;
+            return queue;
         }
     }
 }
\ No newline at end of file

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

--- a/Adaptor/Controller/Router/AbstractUseCaseRouter.cs
+++ b/Adaptor/Controller/Router/AbstractUseCaseRouter.cs
@@ -9,18 +9,11 @@ namespace CleanAuLait.Adaptor.Controller.Router
     {
         private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
 
-        protected readonly IRequestScopeGenerator scopeGenerator;
-
-        public AbstractUseCaseRouter(IRequestScopeGenerator scopeGenerator)
-        {
-            this.scopeGenerator = scopeGenerator;
-        }
-
-        protected T GetComponent(IScopedProvider scope, IUseCaseRouterAware req)
+        protected T GetComponent(IScopedProvider scopedProvider, IUseCaseRouterAware req)
         {
             Type interactorType = req.GetInteractorType();
 
-            if (!interactorType.IsAssignableTo(typeof(T)))
+            if (!typeof(T).IsAssignableFrom(interactorType))
             {
                 logger.Trace($"{interactorType.Name} not assignable to {typeof(T).Name}.)");
                 return default;
@@ -28,7 +21,7 @@ namespace CleanAuLait.Adaptor.Controller.Router
 
             try
             {
-                return (T)scope.Resolve(interactorType);
+                return (T)scopedProvider.Resolve(interactorType);
             }
             catch (ContainerResolutionException e)
             {

--- a/Adaptor/Controller/Router/AsyncUseCaseRouter.cs
+++ b/Adaptor/Controller/Router/AsyncUseCaseRouter.cs
@@ -12,20 +12,14 @@ namespace CleanAuLait.Adaptor.Controller.Router
     {
         private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
 
-        public AsyncUseCaseRouter(IRequestScopeGenerator scopeGenerator) : base(scopeGenerator)
-        {
-        }
-
         public async Task<UseCaseResponse> HandleAsync(UseCaseRequest req, IAsyncHandlerContext context)
         {
             try
             {
-                using IScopedProvider scope = scopeGenerator.CreateScope();
                 logger.Trace($"-> ASYNC REQUEST = {req}");
 
-                IAsyncUseCaseRouterAwareInteractor asyncInteractor = GetComponent(scope, req);
+                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.");
@@ -42,7 +36,6 @@ namespace CleanAuLait.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,20 +12,14 @@ namespace CleanAuLait.Adaptor.Controller.Router
     {
         private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
 
-        public UseCaseRouter(IRequestScopeGenerator scopeGenerator) : base(scopeGenerator)
-        {
-        }
-
         public UseCaseResponse Handle(UseCaseRequest req, IHandlerContext context)
         {
             try
             {
-                using IScopedProvider scope = scopeGenerator.CreateScope();
                 logger.Trace($"-> REQUEST = {req}");
 
-                IUseCaseRouterAwareInteractor interactor = GetComponent(scope, req);
+                IUseCaseRouterAwareInteractor interactor = GetComponent(context.ScopedProvider, req);
 
-                // routing map is null, or request type key not registered on routing map.
                 if (interactor == null)
                 {
                     logger.Error("get interactor instance failed.");
@@ -42,7 +36,6 @@ namespace CleanAuLait.Adaptor.Controller.Router
             }
             catch (DIException e)
             {
-                // component concrete instance not registered on di container.
                 string msg = $"コンポーネントがDIコンテナに登録されていません：{e}";
                 throw new ApplicationException(msg, e);
             }

--- a/CleanAuLaitModule.cs
+++ b/CleanAuLaitModule.cs
@@ -24,9 +24,6 @@ namespace CleanAuLait
 
             containerRegistry.RegisterSingleton<IRequestScopeGenerator, RequestScopeGenerator>();
 
-            containerRegistry.RegisterSingleton<IHandlerContextFactory, HandlerContextFactory>();
-            containerRegistry.RegisterSingleton<IAsyncHandlerContextFactory, AsyncHandlerContextFactory>();
-
             ///
             /// Resources
             ///