core grpc Télécharger - core grpc Téléchargement du code source

Si vous avez des questions, veuillez ajouter directement QQ : 2292709323, WeChat : yaofengv, contact

Overt.Core.Grpc – Base Grpc.Core est fourni avec Google
Overt.Core.Grpc.H2 - Base Grpc.Net est fourni avec Microsoft

Overt.Core.Grpc

Description de la hiérarchie du projet

Overt.Core.Grpc v1.0.6
Basé sur le pilote Grpc.Core de Google, il convient aux scénarios de service de console et implémente des scénarios de microservices basés sur des connexions longues TCP.

1. Répertoire du projet

 |-Config                                        配置模型
|
|-Client                                        客户端功能实现，服务发现
|
|-dllconfigs                                    配置文件保存
|
|-Intercept                                     拦截器
|-|-IServerTracer                               服务端拦截器接口
|-|-IClientTracer                               客户端拦截器接口
|  
|-Manager                                       启动、客户端调用类
|-|-GrpcServiceManager.cs                       服务端启动类
|-|-GrpcClientManager.cs                        客户端获取Client类
|
|-Service                                       服务端
|
|-GrpcServiceCollectionExtensions.cs            netcore注入

2. Versions et assistance

Version Nuget : v1.0.6
Prise en charge du framework : Framewok 4.5 - 4.6 / NetStandard 2.0

3. Dépendances du projet

NetStandard 2.0

Consul 0.7 .2 .6  
Google . Protobuf 3.8 .0
Grpc 1.21 .0
Microsoft . Extensions . Configuration . Json 2.0 .0
Microsoft . Extensions . Options . ConfigurationExtensions 2.0 .0

Cadre 4.5-4.7

Consul 0.7 .2 .6  
Google . Protobuf 3.8 .0
Grpc 1.21 .0

utiliser

1. Référence du package Nuget

 Install - Package Overt . Core . Grpc - Version 1.0 .6

2. Informations de configuration

Priorité : {Centre de configuration tiers} > Variables d'environnement > Configuration interne de l'hôte > Obtenir automatiquement l'intranet IP

(1) Informations sur la configuration du serveur

Prend en charge le fichier de configuration par défaut appsettings.json [le nœud Consul n'est pas requis, sinon, ce n'est pas un cluster]

{
  "GrpcServer" : {
    "Service" : {
      "Name" : " OvertGrpcServiceApp " ,                    // 服务名称使用服务名称去除点：OvertGrpcServiceApp
      "Host" : " service.g.lan " ,                          // 专用注册的域名 （可选）格式：ip[:port=default]
      "HostEnv" : " serviceaddress " ,                      // 获取注册地址的环境变量名字（可选，优先）环境变量值格式：ip[:port=default]
      "Port" : 10001 ,                                    // 端口自定义
      "Consul" : {
        "Path" : " dllconfigs/consulsettings.json "        // Consul路径
      }
    }
  }
}

// 添加section
< configSections >
  < section name = " grpcServer " type = " Overt.Core.Grpc.GrpcServerSection, Overt.Core.Grpc " />
</ configSections >

// 添加节点
< grpcServer >
  < service name = " OvertGrpcServiceApp " port = " 10005 " host = "专用注册的域名（可选）格式：ip[:port=default] " hostEnv = "获取注册地址的环境变量名字（可选）环境变量值格式：ip[:port=default] " >
    < registry >
      < consul path = " dllconfigs/Consul.config " />
    </ registry >
  </ service >
</ grpcServer >

(2) Informations de configuration client

Dénomination : dossier [espace de noms].dll.json (dllconfigs)

{
  "GrpcClient" : {
    "Service" : {
      "Name" : " grpcservice " ,                        // 服务名称与服务端保持一致
      "MaxRetry" :  0 ,                               // 最大可重试次数，默认不重试
      "Discovery" : {
        "EndPoints" : [                              // 单点模式
          {
            "Host" : " 127.0.0.1 " ,
            "Port" : 10001
          }
        ],
        "Consul" : {                                 // Consul集群,集群优先原则
          "Path" : " dllconfigs/consulsettings.json "
        }
      }
    }
  }
}

<? xml version = " 1.0 " encoding = " utf-8 " ?>
< configuration >
  < configSections >
    < section name = " grpcClient " type = " Overt.Core.Grpc.GrpcClientSection, Overt.Core.Grpc " />
  </ configSections >

  < grpcClient >
    < service name = " " maxRetry = " 0 " >
      < discovery >
        < server >
          < endpoint host = " " port = " " ></ endpoint >
          < endpoint host = " " port = " " ></ endpoint >
        </ server >
        < consul path = " dllconfigs/Consul.config " ></ consul >
      </ discovery >
    </ service >
  </ grpcClient >
</ configuration >

(3) Fichier de configuration du consul

Nom : consulsettings.json Ne pas modifier

{
  "ConsulServer" : {
    "Service" : {
      "Address" : " http://consul.g.lan "     // 默认8500端口
    }
  }
}

<? xml version = " 1.0 " encoding = " utf-8 " ?>
< configuration >
  < configSections >
    < section name = " consulServer " type = " Overt.Core.Grpc.ConsulServerSection, Overt.Core.Grpc " />
  </ configSections >
  < consulServer >
    < service address = " http://consul.g.lan " ></ service >
  </ consulServer >
</ configuration >

3. Utilisation du serveur

(1) NetCore

Mode d'injection de dépendance de force

 services . AddSingleton < GrpcExampleService . GrpcExampleServiceBase , GrpcExampleServiceImpl > ( ) ;          // Grpc服务的实现
services . AddSingleton < IHostedService , GrpcExampleHostedService > ( ) ;                                   // Grpc服务启动服务类：如下
services . AddGrpcTracer < ConsoleTracer > ( ) ;                                                             // Grpc注入拦截器，继承IServerTracer（可选）

// 使用第三方配置
services . AddGrpcConfig ( config => 
{
    // 以配置中心apollo为例
    config . AddApollo ( context . Configuration . GetSection ( "apollo" ) ) . AddDefault ( ) ;
} ) ;

 using Microsoft . Extensions . Hosting ;
using Overt . Core . Grpc ;
using Overt . GrpcExample . Service . Grpc ;
using System . Threading ;
using System . Threading . Tasks ;

namespace Overt . GrpcService . App
{
    public class GrpcService : IHostedService
    {
        GrpcExampleService . GrpcExampleServiceBase _grpcServiceBase ;
        IServerTracer _tracer ;
        public GrpcService ( GrpcExampleService . GrpcExampleServiceBase serviceBase , IServerTracer tracer )         // 依赖注入Grpc服务基础类
        {
            _serviceBase = serviceBase ;
            _tracer = tracer ;
        }


        public Task StartAsync ( CancellationToken cancellationToken )
        {
            return Task . Factory . StartNew ( ( ) =>
            {
                GrpcServiceManager . Start ( GrpcExampleService . BindService ( _serviceBase ) , _tracer ) ;
            } , cancellationToken ) ;
        }

        public Task StopAsync ( CancellationToken cancellationToken )
        {
            return Task . Factory . StartNew ( ( ) =>
            {
                GrpcServiceManager . Stop ( ) ;
            } , cancellationToken ) ;
        }
    }
}

Écriture de classe d’implémentation

原因：服务启动的时候是一个单例，那么所有服务之下的全部是单实例，而数据层需要使用多实例

// 只注入 IServiceProvider
IServiceProvider _provider ;
public GrpcExampleServiceImpl ( IServiceProvider provider )
{
    _provider = provider ;
}

// 其他利用provider即时获取
using ( var scope = _provider . CreateSocpe ( ) )
{
    var _userService = scope . ServiceProvider . GetService < IUserService > ( ) ;
}

(2) Cadre 4.6

Appelez directement GrpcServiceManager pour démarrer

 using Grpc . Core ;
using Overt . Core . Grpc ;
using Overt . Log ;
using System ;

namespace Overt . GrpcService
{
    public class MainService
    {
        public MainService ( )
        {
            
        }
        public void Start ( string serviceName )               // 启动服务
        {
            GrpcServiceManager . Start ( Library . GrpcService . BindService ( new GrpcServiceImpl ( ) ) , tracer : new ConsoleTracer ( ) , whenException : ( ex ) =>
            {
                LogHelper . Info ( "" , ex ) ;
            } ) ;
        }

        public void Stop ( string serviceName )                // 停止服务
        {
            GrpcServiceManager . Stop ( ) ;
        }
        public void ShutDown ( string serviceName )
        {
            GrpcServiceManager . Stop ( ) ;
        }
    }
}

4. Utilisation par les clients

(1) NetCore

Mode d'injection de dépendance de force
Le fichier de configuration utilise [namespace].dll.json par défaut. Les packages Nuget peuvent être générés via l'outil vs.menu.
Appelez directement les personnes suivantes pendant l'injection :

 // 注入Grpc客户端
services . AddGrpcClient ( ) ;

// 自定义配置文件 / 默认使用命名空间.dll.json
services . Configure < GrpcClientOptions < GrpcExampleServiceClient > > ( ( cfg ) =>
{
    cfg . ConfigPath = "dllconfig/Overt.GrpcExample.Service.Grpc.dll.json" ;  // 可不传递
} ) ;

// 使用第三方配置
services . AddGrpcConfig ( config => 
{
    // 以配置中心apollo为例
    config . AddApollo ( context . Configuration . GetSection ( "apollo" ) ) . AddDefault ( ) ;
} ) ;


// 获取注入的对象
IGrpcClient < GrpcExampleServiceClient > _grpcClient ;
public IndexModel ( IGrpcClient < GrpcExampleServiceClient > grpcClient )
{
    _grpcClient = grpcClient ;
}


var res = _grpcClient . Client . Ask ( new Service . Grpc . AskRequest ( ) { Key = "abc" } ) ;

(2) Cadre

Classe proxy client, compilée en Dll, le code source est le suivant, peut être ignoré

 using Grpc . Core ;
using Overt . Core . Grpc ;
using Overt . Core . Grpc . Intercept ;
using System ;
using System . Collections . Concurrent ;
using System . IO ;
using __GrpcService = Overt . GrpcExample . Service . Grpc . GrpcExampleService ;
namespace Overt . GrpcExample . Service . Grpc
{
#if NET45 || NET46 || NET47
    public class ClientManager
    {
        public static IClientTracer Tracer { get ; set ; } = default ( IClientTracer ) ;
        private static string DefaultConfigPath { get ; set ; } = "dllconfigs/Overt.GrpcExample.Service.Grpc.dll.config" ;
        public static __GrpcService . GrpcExampleServiceClient Instance
        {
            get
            {
                return ClientManager < __GrpcService . GrpcExampleServiceClient > . Instance ;
            }
        }
        private static readonly ConcurrentDictionary < Type , string > configMap = new ConcurrentDictionary < Type , string > ( ) ;
        public static void Configure < T > ( string configPath ) { configMap . AddOrUpdate ( typeof ( T ) , configPath , ( t , s ) => configPath ) ; }
        public static string GetConfigure < T > ( ) { if ( configMap . TryGetValue ( typeof ( T ) , out string configPath ) ) return configPath ; return DefaultConfigPath ; }
    }
    public class ClientManager < T > : ClientManager where T : ClientBase
    {
        public static new T Instance
        {
            get
            {
                var configPath = GetConfigure < T > ( ) ;
                var abConfigPath = Path . Combine ( AppDomain . CurrentDomain . BaseDirectory , configPath ) ;
                return GrpcClientManager < T > . Get ( abConfigPath , Tracer ) ;
            }
        }
    }
#endif
}

Exécuter à l'aide de la classe proxy

 // 自定义配置文件 / 默认使用命名空间.dll.json / 在主进程入口进行配置T为服务Client
ClientManger.Configure<T>("dllconfig/abc.config");

ClientManager.Instance.[Method]

// T为服务Client
ClientManager<T>.Instance.[Method]

5. Instructions de mise à jour

2024-07-22 v1.0.9

le consul prend en charge le jeton

2022-04-06 v1.0.8

Mettez à niveau le pilote sous-jacent vers la dernière version
Grpc => 2.40.0

2021-07-01 v1.0.7

Mettez à niveau le pilote sous-jacent vers la dernière version
Google.Protobuf => 3.17.3

2021-03-31 v1.0.6

Refactoriser GrpcClientOptions
Mettez à niveau le pilote vers la dernière version

2021-03-30 v1.0.5

Tracer offre la possibilité de modifier la cible du canal, permettant une sélection personnalisée externe de nœuds ;
Mettez à niveau le pilote sous-jacent vers la dernière version
Ajouter une injection d'intercepteur personnalisée
Ajustez la configuration des paramètres de ServiceStart et utilisez GrpcOptions pour l'entreprendre.
Augmentez l'acquisition personnalisée d'invocateurs et augmentez l'acquisition de ServiceId
Prise en charge de la stratégie d'acquisition d'invocateurs personnalisés pour la version du framework

2021-02-25 v1.0.4.1

Ajoutez la prise en charge de la configuration tierce, telle qu'Apollo, qui peut être étendue à l'aide de services.AddGrpcConfig (actuellement, seul dotnetcore est pris en charge)

2019-11-28 v1.0.3.1

Optimiser le support des nouvelles versions de Consul

2019-11-28 v1.0.3

Une fois que le centre d'enregistrement a détecté les modifications, il ignore la liste noire et réinitialise toutes les connexions locales.

2019-09-29 v1.0.2

Le client utilise le centre d'enregistrement Consul pour prendre en charge la surveillance des modifications de service unique, les nouveaux services d'enregistrement ou les pannes de service, plus en temps réel.

2019-08-16 v1.0.1

Prise en charge du mode multiservice

2019-08-01 v1.0.0

Modifiez l'espace de noms, mettez à jour le package nuget vers Overt.Core.Grpc et mettez à jour la version par défaut vers 1.0.0

2019-06-05 v1.0.0.1

Lorsque le client ne parvient pas à optimiser le service de connexion, il est mis sur liste noire, ce qui entraîne le problème de l'absence de nœud.

Overt.Core.Grpc.H2