private void AddHttpServiceRouter(Type type, MethodInfo m, RpcServiceAttribute sAttr, RpcMethodAttribute mAttr, RouterAttribute rAttr, HttpRouteOptions options) { var item = new RouteItem { Path = rAttr.Path, AcceptVerb = rAttr.AcceptVerb, Category = rAttr.Category, InvokeMethod = m, MessageId = mAttr.MessageId, ServiceId = sAttr.ServiceId }; //special MessageId; var args = new object[] { this.specialMessageId }; item.InvokeService = this._proxyCreate.MakeGenericMethod(type).Invoke(this._proxy, args); if (rAttr.PluginType != null) { item.Plugin = ActivatorUtilities.CreateInstance(this._provider, rAttr.PluginType) as IHttpPlugin; } options.Items.Add(item); _logger.LogDebug("url:{0},verb:{1},service:{2},method:{3}", item.Path, item.AcceptVerb, type.Name.Split('.').Last(), m.Name); }
private void AddRpcService(Type type, RpcServiceAttribute sAttr, HttpRouteOptions options, params string[] categories) { var methods = type.GetMethods(); foreach (var m in methods) { var mAttr = m.GetCustomAttribute <RpcMethodAttribute>(); if (mAttr == null) { continue; } var rAttr = m.GetCustomAttribute <RouterAttribute>(); if (rAttr == null) { continue; } if (categories != null && categories.Any()) { if (categories.Contains(rAttr.Category)) { AddHttpServiceRouter(type, m, sAttr, mAttr, rAttr, options); } } else { if ("default".Equals(rAttr.Category, StringComparison.OrdinalIgnoreCase)) { AddHttpServiceRouter(type, m, sAttr, mAttr, rAttr, options); } } } }
public RpcClientInterface(Type intf) { if (!intf.IsInterface) { throw new NotSupportedException(); } RpcServiceAttribute serviceAttr = AttributeHelper.GetAttribute <RpcServiceAttribute>(intf); ServiceName = serviceAttr.ServiceName; ClientCheck = serviceAttr.ClientChecking; EnableCounters = serviceAttr.EnableCounters; _methods = new HybridDictionary <string, RpcClientMethodSensor>(); foreach (MethodInfo method in intf.GetMethods()) { RpcClientMethodSensor m; string methodName = method.Name; RpcServiceBatchMethodAttribute battr = AttributeHelper.TryGetAttribute <RpcServiceBatchMethodAttribute>(method); if (battr != null) { if (!string.IsNullOrEmpty(battr.MethodName)) { methodName = battr.MethodName; } m = new RpcClientMethodSensor() { ArgsType = battr.ArgsType, BatchManager = new RpcClientBatchManager(battr.BatchCount, battr.IdleMs) }; } else { RpcServiceMethodAttribute attr = AttributeHelper.GetAttribute <RpcServiceMethodAttribute>(method); if (!string.IsNullOrEmpty(attr.MethodName)) { methodName = battr.MethodName; } m = new RpcClientMethodSensor() { ArgsType = attr.ArgsType, BatchManager = null }; } _methods.Add(methodName, m); } }
public object InvokeRemoteMethod(IInvocation invocation, byte serializeType) { string serviceName = invocation.Method.DeclaringType.Name.TrimStart('I'); string messageName = invocation.Method.Name; var arguments = invocation.Arguments; object firstP = arguments.Length > 0 ? arguments[0] : null; MethodInfo method = invocation.Method; Type returnType = method.ReturnType; RpcServiceAttribute rpcSericeAttr = invocation.Method.DeclaringType.GetCustomAttribute <RpcServiceAttribute>(true); var timeout = rpcSericeAttr != null && rpcSericeAttr.Timeout > 0 ? rpcSericeAttr.Timeout : _clientOptions.Timeout; //可以从接口特性上解析,没有配置才取默认配置 return(InvokeRemoteMethod(serviceName, invocation.Method, firstP, timeout, serializeType)); }
private void InitServiceMetadata() { Type[] types = ReflectionHelper.GetAssembly(_section.ServiceDLL).GetTypes(); foreach (Type type in types) { if (!type.IsInterface) { continue; } RpcServiceAttribute serviceAttribute = (RpcServiceAttribute)type.GetCustomAttribute(typeof(RpcServiceAttribute), false); if (serviceAttribute != null) { ServiceMetadata serviceMetadata = new ServiceMetadata() { ServiceName = type.FullName, ServiceType = type, ServiceImplType = ReflectionHelper.GetServiceImplType(types, type), }; foreach (MethodInfo method in type.GetMembers()) { RpcMethodAttribute methodAttribute = (RpcMethodAttribute)method.GetCustomAttribute(typeof(RpcMethodAttribute), false); if (methodAttribute != null) { MethodMetadata methodMetadata = new MethodMetadata() { MethodName = methodAttribute.MethodName, Method = method }; serviceMetadata.MethodMetadatas.Add(methodMetadata); } } _cacheContainer.Application.ServiceMetadatas.Add(serviceMetadata); } } }
public static void Initialize() { try { string bastPath = AppDomain.CurrentDomain.BaseDirectory; var serviceDlls = ConfigurationManager.AppSettings["rpc.service"].Split(',').ToList(); if (serviceDlls.Count == 0) { throw new NotExistException("没有找到服务实现"); } foreach (var dllPath in serviceDlls) { Assembly assembly = Assembly.LoadFrom(bastPath + "/" + dllPath); List <Type> types = assembly.GetTypes().ToList(); foreach (var type in types) { RpcServiceAttribute attribute = type.GetCustomAttribute <RpcServiceAttribute>(); if (attribute != null) { List <Type> interfaces = type.GetInterfaces().ToList(); foreach (var iInterface in interfaces) { RpcServiceAttribute attribute1 = iInterface.GetCustomAttribute <RpcServiceAttribute>(); if (attribute1 != null) { ServiceContainer.Add(iInterface.FullName, Activator.CreateInstance(type)); } } } } } } catch { throw; } }
private static RpcServiceInfo GetServiceInfoFromRpcAttribute(Type serviceType, Type?implementationType, RpcServiceAttribute rpcAttribute) { string serviceName; string serviceNamespace; // Try to retrieve it from the server side definition if (rpcAttribute.ServerDefinitionType != null) { if (GetRpcServiceAttribute(rpcAttribute.ServerDefinitionType) is RpcServiceAttribute serverRpcAttribute) { serviceName = GetServiceName(rpcAttribute.ServerDefinitionType, serverRpcAttribute); serviceNamespace = GetServiceNamespace(rpcAttribute.ServerDefinitionType, serverRpcAttribute); } else if (GetServiceContractAttribute(rpcAttribute.ServerDefinitionType) is Attribute contractAttribute) { serviceName = GetServiceName(rpcAttribute.ServerDefinitionType, contractAttribute); serviceNamespace = rpcAttribute.ServerDefinitionType.Namespace ?? ""; } else { throw new RpcDefinitionException("Server side definition interface must be tagged with the RpcService or ServiceContract attribute."); } } else { serviceName = GetServiceName(serviceType, rpcAttribute); serviceNamespace = GetServiceNamespace(serviceType, rpcAttribute); } if (!string.IsNullOrEmpty(rpcAttribute.Name) && rpcAttribute.Name != serviceName) { throw new RpcDefinitionException("Name of server side type does not match specified service name.");; } if (!string.IsNullOrEmpty(rpcAttribute.Namespace) && rpcAttribute.Namespace != serviceNamespace) { throw new RpcDefinitionException("Namespace of server side type does not match specified service namespace.");; } var definitionType = rpcAttribute.ServiceDefinitionSide; var metadata = new List <object>(); metadata.AddRange(serviceType.GetCustomAttributes(inherit: true)); if (implementationType != null) { metadata.AddRange(implementationType.GetCustomAttributes(inherit: true)); } return(new RpcServiceInfo ( type: serviceType, @namespace: serviceNamespace, name: serviceName, definitionSide: definitionType, serverType: rpcAttribute.ServerDefinitionType, implementationType: implementationType, isSingleton: rpcAttribute.IsSingleton, metadata: metadata.ToImmutableArray() )); }