golang grpc进阶

protobuf

官方文档
基本数据类型

.proto TypeNotesGo Type
doublefloat64
floatfloat32
int32使用变长编码，对于负值的效率很低，如果你的域有可能有负值，请使用sint64替代int32
uint32使用变长编码uint32
uint64使用变长编码uint64
sint32使用变长编码，这些编码在负值时比int32高效的多int32
sint64使用变长编码，有符号的整型值。编码时比通常的int64高效。int64
fixed32总是4个字节，如果数值总是比总是比228大的话，这个类型会比uint32高效。uint32
fixed64总是8个字节，如果数值总是比总是比256大的话，这个类型会比uint64高效。uint64
sfixed32总是4个字节int32
sfixed64总是8个字节int64
boolbool
string一个字符串必须是UTF-8编码或者7-bit ASCII编码的文本。string
bytes可能包含任意顺序的字节数据。[]byte
  1. 在java中，无符号32位和64位整型被表示成他们的整型对应形似，最高位被储存在标志位中。
  2. 对于所有的情况，设定值会执行类型检查以确保此值是有效。
  3. 64位或者无符号32位整型在解码时被表示成为ilong，但是在设置时可以使用int型值设定，在所有的情况下，值必须符合其设置其类型的要求。
  4. python中string被表示成在解码时表示成unicode。但是一个ASCIIstring可以被表示成str类型。
  5. Integer在64位的机器上使用，string在32位机器上使用
    当一个消息被解析的时候，如果被编码的信息不包含一个特定的singular元素，被解析的对象锁对应的域被设置位一个默认值，对于不同类型指定如下：
    ● 对于strings，默认是一个空string
    ● 对于bytes，默认是一个空的bytes
    ● 对于bools，默认是false
    ● 对于数值类型，默认是0
    ● 对于枚举，默认是第一个定义的枚举值，必须为0;
    ● 对于消息类型（message），域没有被设置，确切的消息是根据语言确定的，详见generated code guide
    对于可重复域的默认值是空（通常情况下是对应语言中空列表）。
    注：对于标量消息域，一旦消息被解析，就无法判断域释放被设置为默认值（例如，例如boolean值是否被设置为false）还是根本没有被设置。你应该在定义你的消息类型时非常注意。例如，比如你不应该定义boolean的默认值false作为任何行为的触发方式。也应该注意如果一个标量消息域被设置为标志位，这个值不应该被序列化传输。
    查看generated code guide选择你的语言的默认值的工作细节。

proto文件中引入另一个proto文件

1.被引用的proto要先转成go代码
2.使用protobuf提供的proto引用格式与自定义的proto引用格式不同
base.proto

syntax = "proto3";
// 生成proto文件所在包路径
package protos;
// 影响go文件生成位置和包名
//.是当前文件夹
option go_package = ".;proto";
message Empty{}
message Pong{
    string id=1;
}

转成go代码

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative base.proto

hello.proto

syntax = "proto3";
// 生成proto文件所在包路径
package protos;
// 影响go文件生成位置和包名
//.是当前文件夹
option go_package = ".;proto";
import "base.proto";
import "google/protobuf/empty.proto";
service Greeter{
    rpc SayHello(HelloRquest)returns(HelloReply);//hello接口
    rpc Ping(google.protobuf.Empty)returns (Pong);
}
message HelloRquest{
    string name=1;//1是编号不是值
    string url=2;
}
message HelloReply{
    string message=1;
}

转成go代码

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative hello.proto

message嵌套

目录结构
在这里插入图片描述

hello.proto

syntax = "proto3";
// 生成proto文件所在包路径
package protos;
// 影响go文件生成位置和包名
//.是当前文件夹
option go_package = ".;proto";
import "base.proto";
import "google/protobuf/empty.proto";
service Greeter{
    rpc SayHello(HelloRquest)returns(HelloReply);//hello接口
    rpc Ping(google.protobuf.Empty)returns (Pong);
}
message HelloRquest{
    string name=1;//1是编号不是值
    string url=2;
}

message HelloReply{
    string message=1;
    repeated Result data=2;
    message Result{
        string name=1;
        string url=2;
    }
}

转换

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative hello.proto

使用

package main

import "GolangStudy/Introduction/grpc/example4/proto"

func main() {
	_ = proto.HelloReply_Result{}
}

枚举类型

目录结构

在这里插入图片描述
hello2.proto

syntax = "proto3";

// 生成proto文件所在包路径
package protos;
// 影响go文件生成位置和包名
//.是当前文件夹
option go_package = ".;proto1";
service Greeter{
    rpc SayHello(HelloRquest)returns(HelloReply);//hello接口
}
enum Gender{
    MALE=0;
    FEMALE=1;
}
message HelloRquest{
    string name=1;//1是编号不是值
    Gender g=3;
}
message HelloReply{
    string message=1;
}

转换

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative hello2.proto

调用

package main

import (
	_ "GolangStudy/Introduction/grpc/example4/proto"
	"GolangStudy/Introduction/grpc/example4/proto1"
	"context"
	"fmt"

	"google.golang.org/grpc"
)

func main() {
	// _ = proto.HelloReply_Result{}
	conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	c := proto1.NewGreeterClient(conn)
	r, err := c.SayHello(context.Background(), &proto1.HelloRquest{
		Name: "bobby",
		G:    proto1.Gender_FEMALE,
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(r.Message)
}

map类型

hello2.proto

syntax = "proto3";

// 生成proto文件所在包路径
package protos;
// 影响go文件生成位置和包名
//.是当前文件夹
option go_package = ".;proto1";
service Greeter{
    rpc SayHello(HelloRquest)returns(HelloReply);//hello接口
}
enum Gender{
    MALE=0;
    FEMALE=1;
}
message HelloRquest{
    string name=1;//1是编号不是值
    Gender g=2;
    map<string,string> mp=3;
}
message HelloReply{
    string message=1;
}

转换

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative hello2.proto

使用

package main

import (
	_ "GolangStudy/Introduction/grpc/example4/proto"
	"GolangStudy/Introduction/grpc/example4/proto1"
	"context"
	"fmt"

	"google.golang.org/grpc"
)

func main() {
	// _ = proto.HelloReply_Result{}
	conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	c := proto1.NewGreeterClient(conn)
	r, err := c.SayHello(context.Background(), &proto1.HelloRquest{
		Name: "bobby",
		G:    proto1.Gender_FEMALE,
		Mp: map[string]string{
			"name":    "bobby",
			"company": "mooc",
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(r.Message)
}

timestamp类型

hello2.proto

syntax = "proto3";

// 生成proto文件所在包路径
package protos;
// 影响go文件生成位置和包名
//.是当前文件夹
option go_package = ".;proto1";
import "google/protobuf/timestamp.proto";
service Greeter{
    rpc SayHello(HelloRquest)returns(HelloReply);//hello接口
}
enum Gender{
    MALE=0;
    FEMALE=1;
}
message HelloRquest{
    string name=1;//1是编号不是值
    Gender g=2;
    map<string,string> mp=3;
    google.protobuf.Timestamp addTime=4;
}
message HelloReply{
    string message=1;
}

转换

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative hello2.proto

使用

package main

import (
	_ "GolangStudy/Introduction/grpc/example4/proto"
	"GolangStudy/Introduction/grpc/example4/proto1"
	"context"
	"fmt"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/protobuf/types/known/timestamppb"
)

func main() {
	// _ = proto.HelloReply_Result{}
	conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	c := proto1.NewGreeterClient(conn)
	r, err := c.SayHello(context.Background(), &proto1.HelloRquest{
		Name: "bobby",
		G:    proto1.Gender_FEMALE,
		Mp: map[string]string{
			"name":    "bobby",
			"company": "mooc",
		},
		AddTime: timestamppb.New(time.Now()),
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(r.Message)
}

grpc

metadata

grpc让我们可以像本地调用一样实现远程调用，对于每一次的RPC调用中，都可能会有一些有用的数据，而这些数据就可以通过metadata来传递。metadata是以key-value的形式存储数据的，其中key是string类型，而value是[]string，即一个字符串数组类型。metadata使得client和server能够为对方提供关于本次调用的一些信息，就像一次http请求的RequestHeader和ResponseHeader一样。http中header的生命周周期是一次http请求，那么metadata的生命周期就是一次rpc调用。
实例化

//第一种方式
md := metadata.New(map[string]string{"key1": "val1", "key2": "val2"})
//第二种方式 key不区分大小写，会被统一转成小写。
md := metadata.Pairs(
    "key1", "val1",
    "key1", "val1-2", // "key1" will have map value []string{"val1", "val1-2"}
    "key2", "val2",
)

使用

//发送

md := metadata.Pairs("key", "val")

// 新建一个有 metadata 的 context
ctx := metadata.NewOutgoingContext(context.Background(), md)

// 单向 RPC
response, err := client.SomeRPC(ctx, someRequest)
//接收
func (s *server) SomeRPC(ctx context.Context, in *pb.SomeRequest) (*pb.SomeResponse, err) {
    md, ok := metadata.FromIncomingContext(ctx)
    // do something with metadata
}

使用例子

拦截器

grpc Go支持“拦截器”，即在将请求传递到用户的应用程序逻辑之前在 grpc服务器上执行的中间件，或者在用户调用时在 grpc 客户端上执行的中间件。它是实现常见模式的完美方式：身份验证、日志记录、跟踪、指标、验证、重试、速率限制等，它们可以成为出色的通用构建块，让您轻松构建多个微服务。
实例
目录结构
在这里插入图片描述
hello.proto

syntax = "proto3";
option go_package = ".;proto";
service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply);
}
//将 sessionid放入 放入cookie中 http协议
message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

生成

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative hello2.proto

server

package main

import (
	"context"
	"fmt"
	"net"

	"google.golang.org/grpc"

	"GolangStudy/Introduction/grpc/interpretor/proto"
)

type Server struct{}

func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply,
	error) {
	return &proto.HelloReply{
		Message: "hello " + request.Name,
	}, nil
}

func main() {
	var interceptor grpc.UnaryServerInterceptor
	interceptor = func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
		// 继续处理请求
		fmt.Println("接收到新请求")
		res, err := handler(ctx, req)
		fmt.Println("请求处理完成")
		return res, err
	}
	var opts []grpc.ServerOption
	opts = append(opts, grpc.UnaryInterceptor(interceptor))

	g := grpc.NewServer(opts...)
	proto.RegisterGreeterServer(g, &Server{})
	lis, err := net.Listen("tcp", "0.0.0.0:50051")
	if err != nil {
		panic("failed to listen:" + err.Error())
	}
	err = g.Serve(lis)
	if err != nil {
		panic("failed to start grpc:" + err.Error())
	}
}

client

package main

import (
	"context"
	"fmt"
	"time"

	"google.golang.org/grpc"

	"GolangStudy/Introduction/grpc/interpretor/proto"
)

func interceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
	start := time.Now()
	err := invoker(ctx, method, req, reply, cc, opts...)
	fmt.Printf("method=%s req=%v rep=%v duration=%s error=%v\n", method, req, reply, time.Since(start), err)
	return err
}

func main() {
	//stream
	var opts []grpc.DialOption

	opts = append(opts, grpc.WithInsecure())
	// 指定客户端interceptor
	opts = append(opts, grpc.WithUnaryInterceptor(interceptor))

	conn, err := grpc.Dial("localhost:50051", opts...)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	r, err := c.SayHello(context.Background(), &proto.HelloRequest{Name: "bobby"})
	if err != nil {
		panic(err)
	}
	fmt.Println(r.Message)
}

拦截器框架

auth认证

hello.proto

syntax = "proto3";
option go_package = ".;proto";
service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

生成

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative hello2.proto

server

package main

import (
	"context"
	"fmt"
	"net"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"

	"GolangStudy/Introduction/grpc/token_auth/proto"
)

type Server struct{}

func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply,
	error) {
	return &proto.HelloReply{
		Message: "hello " + request.Name,
	}, nil
}

func main() {
	var interceptor grpc.UnaryServerInterceptor
	interceptor = func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
		// 继续处理请求
		fmt.Println("接收到新请求")
		md, ok := metadata.FromIncomingContext(ctx)
		if !ok {
			return resp, status.Error(codes.Unauthenticated, "无token认证信息")
		}
		var (
			appid  string
			appkey string
		)
		if va1, ok := md["appid"]; ok {
			appid = va1[0]
		}
		if va1, ok := md["appkey"]; ok {
			appkey = va1[0]
		}
		fmt.Println(appid, appkey)
		if appid != "101010" || appkey != "i am key" {
			return resp, status.Error(codes.Unauthenticated, "无token认证信息")
		}
		res, err := handler(ctx, req)
		fmt.Println("请求处理完成")
		return res, err
	}
	var opts []grpc.ServerOption
	opts = append(opts, grpc.UnaryInterceptor(interceptor))

	g := grpc.NewServer(opts...)
	proto.RegisterGreeterServer(g, &Server{})
	lis, err := net.Listen("tcp", "0.0.0.0:50051")
	if err != nil {
		panic("failed to listen:" + err.Error())
	}
	err = g.Serve(lis)
	if err != nil {
		panic("failed to start grpc:" + err.Error())
	}
}

client

package main

import (
	"context"
	"fmt"

	"GolangStudy/Introduction/grpc/token_auth/proto"

	"google.golang.org/grpc"
)

type customCredential struct{}

func (cc *customCredential) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
	return map[string]string{
		"appid":  "101010",
		"appkey": "i am key",
	}, nil
}

// RequireTransportSecurity indicates whether the credentials requires
// transport security.
func (cc *customCredential) RequireTransportSecurity() bool {
	return false
}
func main() {
	// interceptor := func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
	// 	start := time.Now()
	// 	md := metadata.New(map[string]string{
	// 		"appid":  "101010",
	// 		"appkey": "i am key",
	// 	})
	// 	ctx = metadata.NewOutgoingContext(context.Background(), md)
	// 	err := invoker(ctx, method, req, reply, cc, opts...)
	// 	fmt.Printf("method=%s req=%v rep=%v duration=%s error=%v\n", method, req, reply, time.Since(start), err)
	// 	return err
	// }
	//stream
	var opts []grpc.DialOption

	opts = append(opts, grpc.WithInsecure())
	// 指定客户端interceptor
	opts = append(opts, grpc.WithPerRPCCredentials(&customCredential{}))

	conn, err := grpc.Dial("127.0.0.1:50051", opts...)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	r, err := c.SayHello(context.Background(), &proto.HelloRequest{Name: "bobby"})
	if err != nil {
		panic(err)
	}
	fmt.Println(r.Message)
}

验证器

实例
Protocol Buffer Validation
使用的mac电脑，使用官网的第二种第三种都试过了不可以，第二种在$GOPATH:bin找不到protoc-gen-validate文件，第三种能找到但是将proto转换成go文件时会一直报如下错误，最后使用了第一种才成功。

protoc-gen-validate: program not found or is not executable
Please specify a program using absolute path or make sure the program is available in your PATH system variable
--validate_out: protoc-gen-validate: Plugin failed with status code 1.

//第一种
go install github.com/envoyproxy/protoc-gen-validate@latest

//第二种
go get -d github.com/envoyproxy/protoc-gen-validate

//第三种
git clone https://github.com/bufbuild/protoc-gen-validate.git
cd $GOPATH/bin
cd protoc-gen-validate 
make build

hello.proto

syntax = "proto3";

option go_package=".;proto";
import "validate.proto";

service Greeter {
    rpc SayHello (Person) returns (Person);
}

message Person {
    uint64 id    = 1 [(validate.rules).uint64.gt    = 999];

    string email = 2 [(validate.rules).string.email = true];
    string mobile  = 3 [(validate.rules).string = {
                      pattern:  "^1[3456789]\\d{9}$"}];

}

转换

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative  --validate_out="lang=go:." hello.proto

client

package main

import (
	"GolangStudy/Introduction/grpc/validate/proto"
	"context"
	"fmt"

	"google.golang.org/grpc"
)

type customCredential struct{}

func main() {
	var opts []grpc.DialOption

	//opts = append(opts, grpc.WithUnaryInterceptor(interceptor))
	opts = append(opts, grpc.WithInsecure())

	conn, err := grpc.Dial("localhost:50051", opts...)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	//rsp, _ := c.Search(context.Background(), &empty.Empty{})
	rsp, err := c.SayHello(context.Background(), &proto.Person{
		Id:     9999,
		Email:  "bobby@qq.com",
		Mobile: "19999999999",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(rsp.Id)
}

server

package main

import (
	"context"
	"net"

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"google.golang.org/grpc"

	"GolangStudy/Introduction/grpc/validate/proto"
)

type Server struct{}

func (s *Server) SayHello(ctx context.Context, request *proto.Person) (*proto.Person,
	error) {
	return &proto.Person{
		Id: 32,
	}, nil
}

type Validator interface {
	Validate() error
}

func main() {
	var interceptor grpc.UnaryServerInterceptor
	interceptor = func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
		// 继续处理请求
		if r, ok := req.(Validator); ok {
			if err := r.Validate(); err != nil {
				return nil, status.Error(codes.InvalidArgument, err.Error())
			}
		}

		return handler(ctx, req)
	}
	var opts []grpc.ServerOption
	opts = append(opts, grpc.UnaryInterceptor(interceptor))

	g := grpc.NewServer(opts...)
	proto.RegisterGreeterServer(g, &Server{})
	lis, err := net.Listen("tcp", "0.0.0.0:50051")
	if err != nil {
		panic("failed to listen:" + err.Error())
	}
	err = g.Serve(lis)
	if err != nil {
		panic("failed to start grpc:" + err.Error())
	}
}

错误码

CodeNumberDescription
OK0Not an error; returned on success.
CANCELLED1操作被取消，通常是由调用者取消的。
UNKNOWN2未知错误。例如，当从另一个地址空间接收到的状态值属于该地址空间中未知的错误空间时，可能会返回此错误。此外，由未返回足够错误信息的 API 引发的错误也可能会转换为此错误。
INVALID_ARGUMENT3客户端指定了无效参数。请注意，这与 FAILED_PRECONDITION 不同。
DEADLINE_EXCEEDED4操作完成之前截止日期已过。对于更改系统状态的操作，即使操作已成功完成，也可能会返回此错误。例如，服务器的成功响应可能会延迟很长时间
NOT_FOUND5未找到某些请求的实体（例如文件或目录）。服务器开发人员请注意：如果整个用户类别的请求被拒绝，例如逐步推出功能或未记录的许可名单，则可以使用 NOT_FOUND。如果拒绝一类用户中的某些用户的请求，例如基于用户的访问控制，则必须使用 PERMISSION_DENIED。
ALREADY_EXISTS6客户端尝试创建的实体（例如文件或目录）已存在
PERMISSION_DENIED7调用者没有执行指定操作的权限。 PERMISSION_DENIED 不得用于因耗尽某些资源而导致的拒绝（对于这些错误，请使用 RESOURCE_EXHAUSTED 代替）。如果无法识别调用者，则不得使用 PERMISSION_DENIED（对于这些错误，请使用 UNAUTHENTICATED）。此错误代码并不意味着请求有效或请求的实体存在或满足其他先决条件
RESOURCE_EXHAUSTED8某些资源已耗尽，可能是每个用户的配额，或者可能是整个文件系统空间不足。
FAILED_PRECONDITION9操作被拒绝，因为系统未处于操作执行所需的状态。例如，要删除的目录非空、rmdir 操作应用于非目录等。服务实现者可以使用以下准则来决定 FAILED_PRECONDITION、ABORTED 和 UNAVAILABLE： (a) 如果客户端可以仅重试失败的调用。 (b) 如果客户端应在更高级别重试（例如，当客户端指定的测试和设置失败时，指示客户端应重新启动读取-修改-写入序列），则使用 ABORTED。 © 如果客户端在系统状态明确修复之前不应重试，则使用 FAILED_PRECONDITION。例如，如果“rmdir”由于目录非空而失败，则应返回 FAILED_PRECONDITION，因为除非从目录中删除文件，否则客户端不应重试。
ABORTED10操作被中止，通常是由于并发问题，例如定序器检查失败或事务中止。请参阅上面的指南来决定 FAILED_PRECONDITION、ABORTED 和 UNAVAILABLE。
OUT_OF_RANGE11尝试的操作超出了有效范围。例如，查找或读取文件末尾之后的内容。与 INVALID_ARGUMENT 不同，此错误指示如果系统状态发生更改则可以修复的问题。例如，如果要求读取不在 [0,2^32-1] 范围内的偏移量，32 位文件系统将生成 INVALID_ARGUMENT，但如果要求读取超过当前偏移量的偏移量，则会生成 OUT_OF_RANGE文件大小。 FAILED_PRECONDITION 和 OUT_OF_RANGE 之间有相当多的重叠。我们建议在应用时使用 OUT_OF_RANGE（更具体的错误），以便迭代空间的调用者可以轻松查找 OUT_OF_RANGE 错误以检测何时完成。
UNIMPLEMENTED12此服务未实现或不支持/启用该操作。
INTERNAL13内部错误。这意味着底层系统所期望的一些不变量已经被打破。该错误代码是为严重错误保留的。
UNAVAILABLE14该服务目前不可用。这很可能是一种瞬态情况，可以通过后退重试来纠正。请注意，重试非幂等操作并不总是安全的。
DATA_LOSS15不可恢复的数据丢失或损坏。
UNAUTHENTICATED16该请求没有该操作的有效身份验证凭据

实例
服务端

status.New(codes.InvalidArgument, "invalid username")

客户端

st, ok := status.FromError(err)
if !ok {
    // Error was not a status error
}
st.Message()
st.Code()

grpc的超时机制

ctx, cancel := context.WithTimeout(context.TODO(), time.Second*3)
defer cancel()
 r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})

实例

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/886659.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Redis: 集群架构，优缺点和数据分区方式和算法

Redis: 集群架构，优缺点和数据分区方式和算法

集群 集群指的就是一组计算机作为一个整体向用户提供一组网络资源 我就举一个简单的例子&#xff0c;比如百度&#xff0c;在北京和你在上海访问的百度是同一个服务器吗&#xff1f;答案肯定是不是的&#xff0c;每一个应用可以部署在不同的地方&#xff0c;但是我们提供的服务…
阅读更多...
Navicat Premium 12 for Mac中文永久版

Navicat Premium 12 for Mac中文永久版

目录 一、安装二、修改rpk文件三、获取请求码四、获取jh码 Tip&#xff1a;由于一些jy词&#xff0c;一直不让我发布&#x1f644;&#xff0c;所以只能用拼音简写代替&#xff0c;是不是很无语&#xff0c;我也很无语&#xff0c;各位自行体会一下&#x1f612; 为了避免每次换…
阅读更多...
1. 如何在服务器上租GPU跑实验 (以AutoDL为例) - 深度学习·科研实践·从0到1

1. 如何在服务器上租GPU跑实验 (以AutoDL为例) - 深度学习·科研实践·从0到1

目录 前言 1. 在AutoDL上注册账号 2. 在算力市场选择GPU 3. 创建实例 4. 控制台-容器实例界面&#xff08;核心&#xff09; 4.1 无卡模式&#xff08;常用&#xff09; 5. 帮助文档 前言 好记性不如烂笔头&#xff0c;本专栏将详细记录下本人学习深度学习工程实践&…
阅读更多...
C（十一）scanf、getchar（第三弹）

C（十一）scanf、getchar（第三弹）

问题引入&#xff1a;如何实现输入一串密码&#xff0c;如&#xff1a;“123 xxxx” &#xff0c;然后读取并确认&#xff0c;是 -- Y&#xff1b;否 -- N。 自然的&#xff0c;我们想到用scanf&#xff0c;但是在使用过程中你是否遇到跟我一样的困惑呢&#xff1f;如下&…
阅读更多...
新闻推荐系统：Spring Boot的创新应用

新闻推荐系统：Spring Boot的创新应用

1系统概述 1.1 研究背景 如今互联网高速发展&#xff0c;网络遍布全球&#xff0c;通过互联网发布的消息能快而方便的传播到世界每个角落&#xff0c;并且互联网上能传播的信息也很广&#xff0c;比如文字、图片、声音、视频等。从而&#xff0c;这种种好处使得互联网成了信息传…
阅读更多...
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-10-02

计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-10-02

计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-10-02 1. APM: Large Language Model Agent-based Asset Pricing Models Authors: Junyan Cheng, Peter Chin https://arxiv.org/abs/2409.17266 APM: 基于大型语言模型的代理资产定价模型&#xff08;LLM Agent-b…
阅读更多...
C++20中头文件concepts的使用

C++20中头文件concepts的使用

<concepts>是C20中新增加的头文件&#xff0c;此头文件是concepts库的一部分&#xff0c;主要用于模板编程、泛型编程。包括 1.core language concepts&#xff1a; std::same_as&#xff1a;指定一种类型(type)与另一种类型是否相同。 std::derived_from&#xff1a;指定…
阅读更多...
＜数据集＞工程机械识别数据集＜目标检测＞

＜数据集＞工程机械识别数据集＜目标检测＞

数据集格式&#xff1a;VOCYOLO格式 图片数量&#xff1a;2644张 标注数量(xml文件个数)&#xff1a;2644 标注数量(txt文件个数)&#xff1a;2644 标注类别数&#xff1a;3 标注类别名称&#xff1a;[dump truck, wheel loader, excavators] 序号类别名称图片数框数1dum…
阅读更多...
学MybatisPlus

学MybatisPlus

1.设置MySql的数据库 spring:datasource:url: jdbc:mysql://127.0.0.1:3306/mp?useUnicodetrue&characterEncodingUTF-8&autoReconnecttrue&serverTimezoneAsia/Shanghaidriver-class-name: com.mysql.cj.jdbc.Driverusername: rootpassword: MySQL123 logging:l…
阅读更多...
【LeetCode: 344. 反转字符串 | 双指针模拟】

【LeetCode: 344. 反转字符串 | 双指针模拟】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
被字节恶心到了

被字节恶心到了

字节 日常逛 xhs 看到一篇吐槽贴&#xff0c;表示被公司恶心到了&#xff1a; 这位网友表示&#xff0c;最近是公司举办了 Q2 和 H1 的优秀员工表彰&#xff0c;自己的 1&#xff08;直属领导&#xff09;评上了&#xff0c;但仔细一看&#xff0c;1 获奖的所有产出都是自己的&…
阅读更多...
Stable Diffusion绘画 | 插件-Deforum：动态视频生成（上篇）

Stable Diffusion绘画 | 插件-Deforum：动态视频生成（上篇）

Deforum 与 AnimateDiff 不太一样&#xff0c; AnimateDiff 是生成丝滑变化视频的&#xff0c;而 Deforum 的丝滑程度远远没有 AnimateDiff 好。 它是根据对比前面一帧的画面&#xff0c;然后不断生成新的相似图片&#xff0c;来组合成一个完整的视频。 Deforum 的优点在于可…
阅读更多...
CSS实现磨砂玻璃效果

CSS实现磨砂玻璃效果

引言 最近看到有一种磨砂玻璃背景效果很好看&#xff0c;自己简单制作了一个美杜莎女王小卡片&#xff0c;效果如下&#xff1a; backdrop-filter: blur(10px); 通过设置背景幕布的模糊程度&#xff0c;结合背景图片&#xff0c;实现磨砂玻璃效果 案例代码 <!DOCTYPE h…
阅读更多...
Linux之实战命令25：xargs应用实例(五十九)

Linux之实战命令25：xargs应用实例(五十九)

简介&#xff1a; CSDN博客专家、《Android系统多媒体进阶实战》一书作者 新书发布&#xff1a;《Android系统多媒体进阶实战》&#x1f680; 优质专栏&#xff1a; Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a; 多媒体系统工程师系列【…
阅读更多...
风格迁移项目一：如何使用

风格迁移项目一：如何使用

前言 由于我不太会pr&#xff0c;所以直接新建的项目&#xff0c; 原项目地址&#xff1a;https://github.com/Optimistism/Style-transfer 原项目代码的讲解地址&#xff1a;https://www.bilibili.com/video/BV1yY4y1c7Cz/ 本项目是对原项目的一点点完善。 项目地址&…
阅读更多...
6.模拟电子技术——共集电极，共基极，多极放大电路

6.模拟电子技术——共集电极，共基极，多极放大电路

写在前面 这个是第六次的笔记&#xff0c;祝大家学习愉快 笔记部分 1.共集电极放大电路 首先&#xff0c;我们再复习一遍组态判断&#xff1a;基极进&#xff0c;发射极出&#xff0c;说明是共集电极放大电路。可能读者已经知道一些结论&#xff0c;先抛开这些&#xff0c;我…
阅读更多...
Qt/C++开源控件 自定义雷达控件

Qt/C++开源控件 自定义雷达控件

使用Qt框架创建一个简单的雷达图&#xff0c;包含动态扫描、目标点生成、刻度和方向标识。代码实现使用C编写&#xff0c;适合用作学习和扩展的基础。 1. 头文件与基本设置 #include "RadarWidget.h" #include <QPainter> #include <QPen> #include &…
阅读更多...
CMU 10423 Generative AI：lec15（Scaling Laws 大规模语言模型的扩展法则）

CMU 10423 Generative AI：lec15（Scaling Laws 大规模语言模型的扩展法则）

文章目录 一 概述1. **扩展规律的背景**2. **两种主要的扩展规律**3. **模型容量扩展规律**4. **信息论下界**5. **计算扩展规律**6. **训练高效性**7. **结论与启示** 二 2bit/parameter 概念&#xff08;模型的存储能力分析&#xff09;**1. 概念解释****2. 图表解读****3. 量…
阅读更多...
匿名方法与Lambda表达式+泛型委托

匿名方法与Lambda表达式+泛型委托

匿名方法 和委托搭配使用&#xff0c;方便我们快速对委托进行传参&#xff0c;不需要我们定义一个新的函数&#xff0c;直接用delegate关键字代替方法名&#xff0c;后面跟上参数列表与方法体。 格式&#xff1a;delegate(参数列表){方法体} lambda表达式 是匿名方法的升级…
阅读更多...
通信工程学习：什么是IP网际协议

通信工程学习：什么是IP网际协议

IP&#xff1a;网际协议 IP网际协议&#xff08;Internet Protocol&#xff0c;简称IP&#xff09;是整个TCP/IP协议栈中的核心协议之一&#xff0c;它负责在网络中传送数据包&#xff0c;并提供寻址和路由功能。以下是对IP网际协议的详细解释&#xff1a; 一、对IP网际协议的…
阅读更多...
最新文章

Copyright @ 2022~2023