Introduction à plusieurs frameworks de services sous .NET

Introduction

Une fois que l'entreprise dispose de plus de services, pour faciliter les appels et pour la gestion future des services, certains cadres de services sont généralement utilisés. Voici les principales introductions. connaître plusieurs frameworks de services. Permettez-moi d'analyser brièvement les concepts de base de ces frameworks de services.

Peut être mis dans un environnement de production

J'ai vu des entreprises investir dans les deux cadres de services suivants. C'est un environnement de production, il ne devrait donc pas y avoir trop de soucis concernant la stabilité.

ServiceStack https://github.com/ServiceStack/ServiceStack

ServiceStack n'a peut-être pas été utilisé, mais ses deux autres Un composant, tout le monde aurait dû l'utiliser, ServiceStack.Redis (outil d'accès Redis), ServiceStack.Text (outil de sérialisation Json), ServiceStack est un framework de service, vous pouvez facilement l'utiliser pour créer des services, le service est basé sur http, In De plus, les appels clients sont fournis. Les méthodes de sérialisation des données incluent Json, XML, binaire et Protobuf, et les services créés ont certaines descriptions.

1 requête http, il y a deux éléments clés, le chemin de la requête et les paramètres. Pour ServiceStack, les paramètres sont des objets, c'est-à-dire que les paramètres dans lesquels il veut passer sont encapsulés. une classe À l'intérieur, ajoutez une étiquette à la classe, et le contenu de l'étiquette est le chemin de la demande, de sorte que lorsque le client appelle, il reflète le chemin et les paramètres de la demande, puis lance l'appel.

Parce que ServiceStack lui-même a fourni une démo, je n'écrirai pas la démo ici. Vous pouvez en tirer des leçons.

Hessian https://sourceforge.net/projects/hessiancsharp/

Hessian est un outil de sérialisation et un cadre de service fournit une implémentation dans plusieurs langages, y compris .net. Ce composant ne semble pas très connu dans le domaine .Net, et il n'a peut-être pas été mis à jour depuis longtemps.

Lorsque vous utilisez Hessian, vous devez d'abord définir les interfaces, puis les dupliquer. Le serveur implémente ces interfaces, puis le client utilise la classe RealProxxy comme proxy. éventuellement être appelé Dans la méthode Invoke de la classe proxy, le nom de la méthode à appeler, les paramètres et autres contenus sont obtenus dans la méthode Invoke, et sont sérialisés et envoyés à une URL unifiée sur le serveur. Cette URL se terminera par. hessian, il doit donc être dans web.config Configurez un handle pour intercepter la requête. Après avoir intercepté la requête, désérialisez les paramètres, puis lancez l'appel par réflexion.

Vous pouvez vous référer à ce blog pour appeler ici http://www.cnblogs.com/lxsfg/archive/2008/08/27/1277777.html

Il existe de nombreux autres frameworks de services, tels que thrift et JSON-RPC, mais comme je ne les ai jamais utilisés auparavant, je ne ferai pas de commentaire ici.

Quelques frameworks de services dans le parc de blogs

Les trois frameworks suivants ont été découverts lorsque j'ai parcouru le parc de blogs, et ils sont tous open source pour l'apprentissage. le framework de service est un bon projet.De plus, je ne vais pas souvent au parc de blogs. Les trois frameworks suivants ont également été vus par hasard. Il devrait y avoir d'autres excellents frameworks de service dans le parc de blogs, mais je n'ai pas découvert. Si vous les trouvez, autant écrire dans la zone de commentaire et apprenons ensemble.

Rabbit.Rpc http://www.cnblogs.com/ants/p/5605754.html

Un peu similaire à Hessin, l'interface de service est également définie en premier . Ensuite, en double, le serveur implémente une logique spécifique en héritant de l'interface pour le client, il extrait toutes les méthodes de l'interface, ainsi que les paramètres de méthode et renvoie les informations sur la valeur par réflexion, puis génère dynamiquement du code pour générer une classe proxy. compilé dynamiquement et placé dans le conteneur. Concernant la classe proxy générée, toutes les méthodes ont une implémentation unifiée, c'est-à-dire qu'elles appellent une méthode Invoke pour envoyer les méthodes et les paramètres à la couche inférieure, et l'assembly de la couche inférieure est envoyé au serveur. La façon de générer du code ici est plus amusante, vous pouvez l'apprendre.

De plus, ce cadre intègre également la gouvernance des services. Les services sont enregistrés auprès de Zookeeper et le client obtient l'adresse de service spécifique via Zookeeper pour appeler. En fait, à ce stade, il ne s'agit pas seulement d'un cadre de services, mais inclut également des fonctions de gouvernance des services.

Je n'ai lu que brièvement le code et je n'ai pas encore complètement compris les détails. Si vous souhaitez en savoir plus, vous pouvez lire le code source.

Dyd.BaseService.ServiceCenter http://git.oschina.net/chejiangyi/Dyd.BaseService.ServiceCenter

Regardez les bases introduction Toutes les fonctions sont disponibles, mais selon l'introduction de l'auteur à ce projet, il est dit que ce projet est basé sur la recherche. Le client pour les appels de service est également généré via le code.

De plus, permettez-moi de vous présenter un peu plus ce blogueur. Il a également un blog

dans le jardin des blogs http://www.cnblogs.com/chejiangyi/, et en a ouvert plusieurs. projets open source sous http://www.cnblogs.com/chejiangyi/ ://git.oschina.net/chejiangyi Ce sont de très bons projets, tels que des services de planification, des services de configuration et des services de surveillance pour les sociétés Internet. À une certaine échelle, ces services sont nécessaires, et ce qui est plus précieux, c'est que ces services sont basés sur .Net, ils ont donc une bonne importance de référence pour certaines sociétés Internet qui utilisent le développement .Net.

Redola.Rpc http://www.cnblogs.com/gaochundong/p/redola_yet_another_csharp_rpc_framework.html

C'est ce que j'ai découvert récemment Le framework utilise le modèle Actor et la sérialisation utilise protobuf-. net, la méthode de transmission est basée sur TCP et le framework TCP utilise ses propres Cowboy.WebSockets. Selon l'introduction, le centre de service est également implémenté, mais comme je ne comprends pas le modèle Actor, je n'ajouterai rien. ici. Étudiants intéressés Vous pouvez lire le blog de l'auteur.

Un framework de service que j'ai écrit moi-même

Après avoir vu tant de frameworks de service, j'en ai écrit un moi-même, qui n'est qu'un appel de service et il est expérimental dans nature et peut être utilisé comme référence.

Le principe du framework est similaire à celui de Hession. Il faut d'abord définir l'interface, puis implémenter l'interface côté serveur. J'ai pris une astuce ici en laissant directement le Controller dans le Web. L'API hérite de l'interface, il n'est donc pas nécessaire d'en définir une spécifiquement. Handle est utilisé pour intercepter les requêtes sans affecter l'accès à l'API Web, donc même si vous utilisez ce framework, cela ne vous empêchera pas d'accéder directement via http. La méthode d'appel du client est similaire à Hession. Il doit également définir un proxy puis collecter des paramètres

Définir d'abord l'interface

Avec le. interface, l'étape suivante consiste à l'implémenter. Ici, j'utilise l'API Web. En plus d'hériter de l'APIController, ce Controller hérite également de l'interface. Dans ce Controller, la logique spécifique de l'interface est implémentée.

En même temps, copiez la dll où se trouve cette interface sur le client. Ici, nous allons introduire une fonction, qui est RealProxy. Il s'agit de la classe proxy fournie. avec .Net et est également utilisé par le mécanisme Hession.

using System;
using System.Linq;
using System.Reflection;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
using Newtonsoft.Json;
using RestSharp;
namespace SimleRPC
{
    public class SimpleProxy : RealProxy
    {
        private readonly Uri _uri;
        public SimpleProxy(Type type, Uri uri) : base(type)
        {
            this._uri = uri;
        }
        public override IMessage Invoke(IMessage msg)
        {
            //msg参数包含调用方法的信息，这里通过封装，使信息更丰富一些
            IMethodCallMessage methodMessage = new MethodCallMessageWrapper((IMethodCallMessage)msg);
            MethodInfo methodInfo = (MethodInfo)methodMessage.MethodBase;
            ParameterInfo[] paramsInfo = methodInfo.GetParameters();  //获取方法调用参数
            //拼装path  类名即controller名， 方法名即action名  这样就表示出具体的url
            string path = "/api/" + methodInfo.DeclaringType.Name + "/" + methodInfo.Name;
            //请求类型，post or get
            bool isHttpGet = methodInfo.CustomAttributes.Any(customAttributeData => customAttributeData.AttributeType.Name == "HttpGetAttribute");
            var client = new RestClient(_uri);
            var request = new RestRequest(path, isHttpGet ? Method.GET : Method.POST);
            //构建参数
            //web api对于传参的一切规则  参考 http://www.cnblogs.com/babycool/p/3922738.html    http://www.cnblogs.com/landeanfen/p/5337072.html 两篇博客
            if (isHttpGet)
            {
                //这里默认get请求的参数都是基本类型
                for (int i = 0; i < paramsInfo.Length; i++)
                {
                    request.AddParameter(paramsInfo[i].Name, methodMessage.Args[i]);
                }
            }
            else
            {
                //对于post请求，要么没有参数(当然基本没有这种情况)，要么只有一个参数（这些是受web api的限制）
                if (paramsInfo.Length > 0)
                {
                    request.AddJsonBody(methodMessage.Args[0]);
                }
            }
            // 发送请求 拿到结果
            IRestResponse response = client.Execute(request);
            var content = response.Content;
            Type returnType = methodInfo.ReturnType;     //获取调用方法返回类型，根据类型反序列化结果
            object returnValue;
            if (IsBaseType(returnType))
            {
                returnValue = Convert.ChangeType(content, returnType);
            }
            else
            {
                returnValue = JsonConvert.DeserializeObject(content, returnType); //如果是一个对象，则用json进行反序列化
            }
            return new ReturnMessage(returnValue, methodMessage.Args, methodMessage.ArgCount, methodMessage.LogicalCallContext, methodMessage);
        }
        /// <summary>
        /// 判断是否是基础类型(int long  double), string 是引用类型，但是也归到基础类型里面
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private static bool IsBaseType(Type type)
        {
            if (type == typeof(string) || type.IsPrimitive)
                return true;
            return false;
        }
    }
}

Tous les appels de méthode appelleront la méthode Invoke. Dans la méthode Invoke, vous pouvez obtenir les informations spécifiques de la méthode appelante, telles que les paramètres, le type de valeur de retour, etc. Ensuite, par réflexion et assemblage, une requête Http est formée. Ici, mon nom de classe d'interface par défaut est le nom du contrôleur et le nom de la méthode d'interface est le nom de l'action.

Enfin, envoyez la demande via RestSharp. Enfin, le résultat http est désérialisé dans la valeur requise pour la valeur de retour de la méthode.

En fait, pour le serveur, peu importe que l'API Web hérite de l'interface. Si ce n'est pas le cas, la signature de l'interface doit être cohérente avec celle de l'interface. signature de la méthode dans l'API Web.

La méthode peut être ajustée via la démo que j'ai écrite. Si cela intéresse quelqu'un, vous pouvez tester d'autres situations.

Enfin

De nombreuses sociétés Internet disposent désormais de leurs propres frameworks RPC, dont certains sont open source, et d'autres sont écrits par eux-mêmes en raison de problèmes historiques. Quant aux méthodes de communication, certaines sont basées sur Http, d'autres basées sur TCP, et les deux protocoles sont compatibles. Il existe également diverses méthodes de sérialisation. Je n'en ai répertorié que 5 ci-dessus. En fait, en recherchant sur github, il existe de nombreux excellents RPC.

RPC n'est qu'une étape dans le processus de développement du projet. Avec RPC, vous pouvez faire beaucoup de choses sur cette base, telles que :

Gouvernance des services sont enregistrés dans le centre de services lors de leur démarrage, ainsi que la gouvernance des services. le client est démarré Lorsque vous obtenez la véritable adresse du centre d'enregistrement, appelez-le directement sans passer par un proxy tel que Nginx. Ici, vous pouvez définir certaines restrictions d'autorisation pour obtenir la véritable adresse, telles que les clients qui peuvent être utilisés et ceux qui ne peuvent pas l'être. utilisés et combien peuvent être utilisés. Vous pouvez vous référer à dubbo ici.

Chemin de requête HTTP Les microservices sont désormais très populaires. Une requête frontale peut passer par plusieurs services back-end. Vous pouvez ajouter RequestId et RequestIndex à l'en-tête http, et. mettre ces services sont liés ensemble, par exemple A->B->C. Lorsque le service A appelle le service B, s'il s'avère qu'il n'y a pas de RequestId dans l'en-tête http, un peut être généré via GuId et RequestIndex. est augmenté de 1. Lorsque le service B appelle le service C, , Parce que le RequestId existe déjà, il est transmis directement et le RequestIndex est augmenté de 1. Ces informations sont enregistrées dans le journal Grâce à l'analyse, l'intégralité de l'appel est enchaînée, et le diagramme de liaison d'appel de l'ensemble du service peut être établi à travers les données complètes.

En plus du diagramme de liens, parce que nous pouvons intercepter chaque appel de service, nous pouvons enregistrer l'heure de l'appel de service, plus le diagramme de liens, l'ensemble du service Les informations seront plus complet.

Ce qui précède est l'introduction de plusieurs frameworks de services sous .NET. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !