重构服务端

liguoliang · liguoliang · commit 82a5ba72d75b · 2023-04-03T14:12:07.000+08:00
diff --git a/src/DotNetCoreRpc.Core/DotNetCoreRpc.Core.csproj b/src/DotNetCoreRpc.Core/DotNetCoreRpc.Core.csproj
@@ -9,7 +9,4 @@
     <PackageReference Include="Microsoft.AspNetCore.Http" Version="2.2.2" />
     <PackageReference Include="System.Text.Json" Version="6.0.7" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="RpcBuilder\" />
-  </ItemGroup>
 </Project>
diff --git a/src/DotNetCoreRpc.Core/FromServicesAttribute.cs b/src/DotNetCoreRpc.Core/FromServicesAttribute.cs
diff --git a/src/DotNetCoreRpc.Server/DotNetCoreRpc.Server.csproj b/src/DotNetCoreRpc.Server/DotNetCoreRpc.Server.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <FrameworkReference Include="Microsoft.AspNetCore.App"/>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\DotNetCoreRpc.Core\DotNetCoreRpc.Core.csproj" />
diff --git a/src/DotNetCoreRpc.Server/DotNetCoreRpcMiddleware.cs b/src/DotNetCoreRpc.Server/DotNetCoreRpcMiddleware.cs
@@ -9,26 +9,25 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using DotNetCoreRpc.Core;
-using DotNetCoreRpc.Core.RpcBuilder;
+using DotNetCoreRpc.Server.RpcBuilder;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace DotNetCoreRpc.Server
 {
     public class DotNetCoreRpcMiddleware
     {
-        private readonly IDictionary<string, Type> _serviceTypes;
-        private readonly IEnumerable<Type> _filterTypes;
+        private readonly RpcServerOptions _rpcServerOptions;
 
         public DotNetCoreRpcMiddleware(RequestDelegate next, RpcServerOptions rpcServerOptions)
         {
-            _serviceTypes = rpcServerOptions.GetRegisterTypes();
-            _filterTypes = rpcServerOptions.GetFilterTypes();
+            _rpcServerOptions = rpcServerOptions;
         }
 
         public async Task InvokeAsync(HttpContext context)
         {
             var requestContent = await context.Request.ReadStringAsync();
-            ResponseModel responseModel = new ResponseModel{ Code = (int)HttpStatusCode.InternalServerError };
+            ResponseModel responseModel = new ResponseModel { Code = (int)HttpStatusCode.InternalServerError };
             if (string.IsNullOrEmpty(requestContent))
             {
                 responseModel.Message = "未读取到请求信息";
@@ -44,13 +43,6 @@ public async Task InvokeAsync(HttpContext context)
                 return;
             }
 
-            if (!_serviceTypes.ContainsKey(requestModel.TypeFullName))
-            {
-                responseModel.Message = $"{requestModel.TypeFullName}未注册";
-                await context.Response.WriteAsync(responseModel.ToJson());
-                return;
-            }
-
             await HandleRequest(context, requestModel);
             return;
         }
@@ -61,8 +53,8 @@ public async Task InvokeAsync(HttpContext context)
         /// <returns></returns>
         private async Task HandleRequest(HttpContext context, RequestModel requestModel)
         {
-            Type serviceType = _serviceTypes[requestModel.TypeFullName];
-            var instance = context.RequestServices.GetService(serviceType);
+            var serviceType = _rpcServerOptions.GetServiceType(requestModel.TypeFullName);
+            var instance = context.RequestServices.GetRequiredService(serviceType);
             var instanceType = instance.GetType();
             var method = instanceType.GetMethod(requestModel.MethodName);
             var methodParamters = method.GetParameters();
@@ -113,7 +105,7 @@ private AspectPiplineBuilder CreatPipleline(RpcContext aspectContext)
                 await aspectContext.HttpContext.Response.WriteAsync(responseModel.ToJson());
             });
 
-            List<RpcFilterAttribute> interceptorAttributes = RpcFilterUtils.GetFilterAttributes(aspectContext, _filterTypes);
+            List<RpcFilterAttribute> interceptorAttributes = RpcFilterUtils.GetFilterAttributes(aspectContext, _rpcServerOptions.GetFilterTypes());
             if (interceptorAttributes.Any())
             {
                 foreach (var item in interceptorAttributes)
diff --git a/src/DotNetCoreRpc.Server/RpcBuilder/AspectPiplineBuilder.cs b/src/DotNetCoreRpc.Server/RpcBuilder/AspectPiplineBuilder.cs
@@ -3,7 +3,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 
-namespace DotNetCoreRpc.Core.RpcBuilder
+namespace DotNetCoreRpc.Server.RpcBuilder
 {
     public class AspectPiplineBuilder
     {
diff --git a/src/DotNetCoreRpc.Server/RpcBuilder/FromServicesAttribute.cs b/src/DotNetCoreRpc.Server/RpcBuilder/FromServicesAttribute.cs
@@ -0,0 +1,10 @@
+﻿using System;
+
+namespace DotNetCoreRpc.Server.RpcBuilder
+{
+    [AttributeUsage(AttributeTargets.Property)]
+    public class FromServicesAttribute : Attribute
+    {
+
+    }
+}
diff --git a/src/DotNetCoreRpc.Server/RpcBuilder/RpcContext.cs b/src/DotNetCoreRpc.Server/RpcBuilder/RpcContext.cs
@@ -2,7 +2,7 @@
 using System.Reflection;
 using Microsoft.AspNetCore.Http;
 
-namespace DotNetCoreRpc.Core.RpcBuilder
+namespace DotNetCoreRpc.Server.RpcBuilder
 {
     public class RpcContext
     {
diff --git a/src/DotNetCoreRpc.Server/RpcBuilder/RpcFilterAttribute.cs b/src/DotNetCoreRpc.Server/RpcBuilder/RpcFilterAttribute.cs
@@ -1,7 +1,7 @@
 ﻿using System;
 using System.Threading.Tasks;
 
-namespace DotNetCoreRpc.Core.RpcBuilder
+namespace DotNetCoreRpc.Server.RpcBuilder
 {
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
     public abstract class RpcFilterAttribute : Attribute
diff --git a/src/DotNetCoreRpc.Server/RpcBuilder/RpcFilterUtils.cs b/src/DotNetCoreRpc.Server/RpcBuilder/RpcFilterUtils.cs
@@ -3,10 +3,10 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using DotNetCoreRpc.Core.RpcBuilder;
+using DotNetCoreRpc.Core;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace DotNetCoreRpc.Core
+namespace DotNetCoreRpc.Server.RpcBuilder
 {
     public static class RpcFilterUtils
     {
@@ -22,7 +22,8 @@ public static List<RpcFilterAttribute> GetFilterAttributes(RpcContext aspectCont
             var methondInfo = aspectContext.Method;
 
             var methondInterceptorAttributes = _methodFilters.GetOrAdd($"{methondInfo.DeclaringType.FullName}#{methondInfo.Name}",
-                key => {
+                key =>
+                {
                     var methondAttributes = methondInfo.GetCustomAttributes(true)
                                    .Where(i => typeof(RpcFilterAttribute).IsAssignableFrom(i.GetType()))
                                    .Cast<RpcFilterAttribute>().ToList();
diff --git a/src/DotNetCoreRpc.Server/RpcBuilder/RpcRequestDelegate.cs b/src/DotNetCoreRpc.Server/RpcBuilder/RpcRequestDelegate.cs
@@ -1,7 +1,7 @@
 ﻿using System;
 using System.Threading.Tasks;
 
-namespace DotNetCoreRpc.Core.RpcBuilder
+namespace DotNetCoreRpc.Server.RpcBuilder
 {
     public delegate Task RpcRequestDelegate(RpcContext context);
 }
diff --git a/src/DotNetCoreRpc.Server/RpcServerOptions.cs b/src/DotNetCoreRpc.Server/RpcServerOptions.cs
@@ -1,96 +1,27 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
-using DotNetCoreRpc.Core.RpcBuilder;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace DotNetCoreRpc.Server
 {
     public class RpcServerOptions
     {
-        private readonly IDictionary<string, Type> _serviceTypes = new Dictionary<string, Type>();
-        private readonly HashSet<Type> _serviceTypeSet = new HashSet<Type>();
-        private readonly HashSet<string> _serviceNameSet = new HashSet<string>();
-        private readonly HashSet<string> _serviceNameSpaceSet = new HashSet<string>();
         private readonly IList<Type> _filterTypes = new List<Type>();
-
-        private readonly IServiceCollection _services;
-
-        public RpcServerOptions(IServiceCollection services)
-        {
-            _services = services;
-        }
+        private readonly ServiceTypeCollection _serviceTypes = new ServiceTypeCollection();
 
         public RpcServerOptions AddFilter<RpcFilterAttribute>()
         {
             _filterTypes.Add(typeof(RpcFilterAttribute));
             return this;
         }
 
-        public RpcServerOptions AddService<TService>()
-            where TService:class
-        {
-            _serviceTypeSet.Add(typeof(TService));
-            return this;
-        }
-
-        public RpcServerOptions AddService(string serviceName)
+        internal IEnumerable<Type> GetFilterTypes()
         {
-            _serviceNameSet.Add(serviceName);
-            return this;
+            return _filterTypes;
         }
 
-        public RpcServerOptions AddNameSpace(string nameSpace)
+        internal Type GetServiceType(string serviceName)
         {
-            _serviceNameSpaceSet.Add(nameSpace);
-            return this;
+            return _serviceTypes[serviceName];
         }
-
-        public IDictionary<string, Type> GetRegisterTypes()
-        {
-            foreach (var serviceType in _serviceTypeSet)
-            {
-                _serviceTypes.TryAdd(serviceType.FullName, serviceType);
-            }
-
-            foreach (var serviceName in _serviceNameSet)
-            {
-                string subServiceName = serviceName[1..];
-                foreach (var service in _services)
-                {
-                    if (serviceName.StartsWith("*") && service.ServiceType.Name.EndsWith(subServiceName))
-                    {
-                        _serviceTypes.TryAdd(service.ServiceType.FullName, service.ServiceType);
-                        continue;
-                    }
-
-                    if (service.ServiceType.Name == serviceName)
-                    {
-                        _serviceTypes.TryAdd(service.ServiceType.FullName, service.ServiceType);
-                    }
-                }
-            }
-
-            foreach (var nameSpace in _serviceNameSpaceSet)
-            {
-                foreach (var service in _services)
-                {
-                    if (service.ServiceType.Namespace == nameSpace)
-                    {
-                        _serviceTypes.TryAdd(service.ServiceType.FullName, service.ServiceType);
-                    }
-                }
-            }
-
-            return _serviceTypes.ToDictionary(i => i.Key, i => i.Value);
-        }
-
-        public IEnumerable<Type> GetFilterTypes()
-        {
-            foreach (var filterType in _filterTypes)
-            {
-                yield return filterType;
-            }
-        } 
     }
 }
diff --git a/src/DotNetCoreRpc.Server/ServerServiceCollectionExtensions.cs b/src/DotNetCoreRpc.Server/ServerServiceCollectionExtensions.cs
@@ -8,7 +8,7 @@ public static class ServiceCollectionExtensions
     {
         public static IServiceCollection AddDotNetCoreRpcServer(this IServiceCollection services, Action<RpcServerOptions> options)
         {
-            RpcServerOptions rpcServerOptions = new RpcServerOptions(services);
+            RpcServerOptions rpcServerOptions = new RpcServerOptions();
             options.Invoke(rpcServerOptions);
             services.TryAddSingleton(rpcServerOptions);
             return services;
diff --git a/src/DotNetCoreRpc.Server/ServiceTypeCollection.cs b/src/DotNetCoreRpc.Server/ServiceTypeCollection.cs
@@ -0,0 +1,34 @@
+﻿using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+namespace DotNetCoreRpc.Server
+{
+    internal class ServiceTypeCollection
+    {
+        private readonly ConcurrentDictionary<string, Type> _serviceTypes = new ConcurrentDictionary<string, Type>();
+        private readonly Assembly[] _assemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+        internal Type this[string serviceName]
+        {
+            get { return GetServiceType(serviceName); }
+        }
+
+        internal Type GetServiceType(string serviceName)
+        {
+            return _serviceTypes.GetOrAdd(serviceName, typeName => {
+                Type serviceType = _assemblies.Select(a => a.GetType(typeName)).FirstOrDefault(t => t != null);
+
+                if (serviceType == null)
+                {
+                    throw new ArgumentNullException($"未能找到{typeName}的定义");
+                }
+
+                return serviceType;
+            });
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using System.Threading.Tasks;`
`5`	`5`
`6`		`-namespace DotNetCoreRpc.Core.RpcBuilder`
	`6`	`+namespace DotNetCoreRpc.Server.RpcBuilder`
`7`	`7`	`{`
`8`	`8`	`public class AspectPiplineBuilder`
`9`	`9`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`using System.Reflection;`
`3`	`3`	`using Microsoft.AspNetCore.Http;`
`4`	`4`
`5`		`-namespace DotNetCoreRpc.Core.RpcBuilder`
	`5`	`+namespace DotNetCoreRpc.Server.RpcBuilder`
`6`	`6`	`{`
`7`	`7`	`public class RpcContext`
`8`	`8`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Threading.Tasks;`
`3`	`3`
`4`		`-namespace DotNetCoreRpc.Core.RpcBuilder`
	`4`	`+namespace DotNetCoreRpc.Server.RpcBuilder`
`5`	`5`	`{`
`6`	`6`	`[AttributeUsage(AttributeTargets.Class \| AttributeTargets.Method)]`
`7`	`7`	`public abstract class RpcFilterAttribute : Attribute`