Descarga core grpc - descarga del código fuente core grpc

Si tiene alguna pregunta, agregue directamente QQ: 2292709323, WeChat: yaofengv, contacto

Overt.Core.Grpc - Base Grpc.Core viene con Google
Overt.Core.Grpc.H2 - Base Grpc.Net viene con Microsoft

Grupo.de.núcleo.abierto

Descripción de la jerarquía del proyecto

Overt.Core.Grpc v1.0.6
Basado en el controlador Grpc.Core de Google, es adecuado para escenarios de servicios de consola e implementa escenarios de microservicios basados en conexiones TCP largas.

1. Directorio de proyectos

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

2. Versión y soporte

Versión de Nuget: v1.0.6
Soporte de marco: Framewok 4.5 - 4.6 / NetStandard 2.0

3. Dependencias del proyecto

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

Marco 4.5-4.7

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

usar

1. Referencia del paquete Nuget

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

2. Información de configuración

Prioridad: {Centro de configuración de terceros} > Variables de entorno > Configuración interna del host > Obtener automáticamente la intranet IP

(1) Información de configuración del servidor

Admite el archivo de configuración predeterminado appsettings.json [No se requiere el nodo cónsul; de lo contrario, no es un clúster]

{
  "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) Información de configuración del cliente

Denominación: carpeta [espacio de nombres].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) Archivo de configuración del cónsul

Nombre: consulsettings.json No cambiar

{
  "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. Uso del servidor

(1) Núcleo neto

Modo de inyección de dependencia de fuerza

 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 ) ;
        }
    }
}

Escritura de clase de implementación

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

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

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

(2) Marco 4.6

Llame directamente a GrpcServiceManager para comenzar

 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. Uso del cliente

(1) Núcleo neto

Modo de inyección de dependencia de fuerza
El archivo de configuración utiliza [espacio de nombres].dll.json de forma predeterminada. Los paquetes Nuget se pueden generar a través de la herramienta vs.menu.
Llame directamente a lo siguiente durante la inyección:

 // 注入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) Marco

La clase de proxy del cliente, compilada en DLL, el código fuente es el siguiente, se puede ignorar

 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
}

Ejecutar usando clase proxy

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

ClientManager.Instance.[Method]

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

5. Actualizar instrucciones

2024-07-22 v1.0.9

El cónsul apoya Token.

2022-04-06 v1.0.8

Actualice el controlador subyacente a la última versión
Grpc => 2.40.0

2021-07-01 v1.0.7

Actualice el controlador subyacente a la última versión
Google.Protobuf => 3.17.3

2021-03-31 v1.0.6

Refactorizar GrpcClientOptions
Actualice el controlador a la última versión

2021-03-30 v1.0.5

Tracer brinda la capacidad de modificar el canal objetivo, lo que permite una selección externa personalizada de nodos;
Actualice el controlador subyacente a la última versión
Agregar inyección de Interceptor personalizada
Ajuste la configuración de parámetros de ServiceStart y utilice GrpcOptions para realizarlo.
Incrementar la adquisición personalizada de invocadores y aumentar la adquisición de ServiceId
Admitir estrategia de adquisición de invocadores personalizados para la versión del marco

2021-02-25 v1.0.4.1

Agregue soporte para configuración de terceros, como apollo, que se puede expandir usando servicios.AddGrpcConfig (actualmente solo se admite dotnetcore)

2019-11-28 v1.0.3.1

Optimizar el soporte para nuevas versiones de Consul

2019-11-28 v1.0.3

Una vez que el centro de registro detecta los cambios, ignora la lista negra y restablece todas las conexiones locales.

2019-09-29 v1.0.2

El cliente utiliza el centro de registro de Consul para respaldar el monitoreo de cambios de servicio único, nuevos servicios de registro o fallas del servicio, más en tiempo real.

2019-08-16 v1.0.1

Admite modo multiservicio

2019-08-01 v1.0.0

Modifique el espacio de nombres, actualice el paquete nuget a Overt.Core.Grpc y actualice la versión predeterminada a 1.0.0

2019-06-05 v1.0.0.1

Cuando el cliente no logra optimizar el servicio de conexión, se incluye en la lista negra, lo que genera el problema de que el nodo no existe.

Grupo.de.núcleo.abierto.H2