rpc入门笔记 0x02 protobuf的杂七杂八

syntax = "proto3"; // 这是个proto3的文件message HelloRequest{  // 创建数据对象string name = 1; // name表示名称，编号是1
}

生成python文件

安装grpcio和grpcio-tools库

pip install grpcio #安装grpc
pip install grpcio-tools #安装grpc tools

生成proto的python文件

python -m grpc_tools.protoc --python_out=. --grpc_python_out=. -I. helloworld.proto
  • python -m grpc_tools.protoc：使用grpc_tools包中的protoc命令进行代码生成。
  • --python_out=.：指定生成的Python代码的存放位置为当前目录。
  • --grpc_python_out=.：指定生成的gRPC代码的存放位置为当前目录。
  • -I.：指定搜索.proto文件的路径为当前目录

总结起来，该命令的作用是将当前目录下的helloworld.proto文件生成对应的Python代码，并将生成的代码存放在当前目录中

python使用grpc

syntax = "proto3";// The greeting service definition.
service Greeter {// Sends a greeting 下面就是暴露出来的一些方法rpc SayHello (HelloRequest) returns (HelloReply) {} // 定义返回什么类型就要返回什么类型rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}rpc SayHelloBidiStream (stream HelloRequest) returns (stream HelloReply) {}
}// The request message containing the user's name.
message HelloRequest {string name = 1;
}// The response message containing the greetings
message HelloReply {string message = 1;
}

生成出来的文件就直接使用他

go使用grpc

生成指令：

#好像是版本不兼容了 protoc -I . helloworld.proto --go_out=plugins=grpc:.
protoc -I . --go_out=. --go-grpc_out=. ./hello.proto

样例：

syntax = "proto3";
option go_package = ".;proto"; // 这个是必须加的// The greeting service definition.
service Greeter {// Sends a greeting 下面就是暴露出来的一些方法rpc SayHello (HelloRequest) returns (HelloReply) {} // 定义返回什么类型就要返回什么类型
}// The request message containing the user's name.
message HelloRequest {string name = 1;
}// The response message containing the greetings
message HelloReply {string message = 1;
}

https://blog.csdn.net/neve_give_up_dan/article/details/126920398

https://github.com/grpc/grpc-go/issues/3794

https://blog.csdn.net/Mirale/article/details/122736894

UnimplementedXxxServer的作用：https://blog.csdn.net/Canon_in_D_Major/article/details/108135724

https://zhuanlan.zhihu.com/p/660634947

go_package

option go_package = "common/stream/proto/v1";

表示生成的Go代码文件应该位于common/stream/proto/v1这个包路径下。换句话说，生成的Go代码文件将被放置在common/stream/proto/v1目录下，并且其package声明会是v1

流模式

grpc的流模式主要有三种：

  • 客户端流模式
  • 服务端流模式
  • 双向流模式

proto文件：stream_proto.proto

syntax = "proto3";option go_package = ".;proto";service Greeter {// 服务端流模式：客户端是流，服务端不是流rpc GetStream(StreamReqData) returns (stream StreamResData); // 服务端流模式rpc PostStream(stream StreamReqData) returns (StreamResData); // 客户端流模式rpc AllStream(stream StreamReqData) returns (stream StreamResData); // 双向流模式
}message StreamReqData{string data = 1;
}message StreamResData{string data = 1;
}

server.go

package mainimport ("GoRpc_quick/stream_grpc_test/proto""fmt""google.golang.org/grpc""net""sync""time"
)const PORT = ":8080"type server struct {proto.UnimplementedGreeterServer
}// 服务端流模式
func (s *server) GetStream(req *proto.StreamReqData, streamServer proto.Greeter_GetStreamServer) error {i := 0for true {streamServer.Send(&proto.StreamResData{Data: fmt.Sprintf("%v\n + %v", time.Now().Unix(), req.Data),})time.Sleep(time.Second)if i++; i > 10 {break}}return nil
}// 客户端流模式
func (s *server) PostStream(streamServer proto.Greeter_PostStreamServer) error {for {recv, err := streamServer.Recv()if err != nil {fmt.Println(err)break}fmt.Println(recv.Data)}return nil
}// 双向流模式
func (s *server) AllStream(streamServer proto.Greeter_AllStreamServer) error {wg := sync.WaitGroup{}wg.Add(2)go func() { // 负责receivedefer wg.Done()for {recv, _ := streamServer.Recv()fmt.Println("收到客户端消息：", recv.Data)}}()go func() {defer wg.Done()for i := 0; i < 10; i++ {streamServer.Send(&proto.StreamResData{Data: "我是服务器"})time.Sleep(time.Second)}}()wg.Wait()return nil
}func main() {listener, err := net.Listen("tcp", PORT)if err != nil {panic(err)}s := grpc.NewServer()proto.RegisterGreeterServer(s, &server{})err = s.Serve(listener)if err != nil {panic("failed to start grpc")}
}

client.go

package mainimport ("GoRpc_quick/stream_grpc_test/proto""context""fmt""google.golang.org/grpc""sync""time"
)func main() {conn, err := grpc.Dial("localhost:8080", grpc.WithInsecure())if err != nil {panic(err)}defer conn.Close()// 服务端流模式（客户端接收流）c := proto.NewGreeterClient(conn)stream, _ := c.GetStream(context.Background(), &proto.StreamReqData{Data: "alice"})for {recv, err := stream.Recv() // 实际上就是socket编程if err != nil {fmt.Println(err.Error())break}fmt.Println(recv)}// 客户端流模式，客户端发送流postStream, err := c.PostStream(context.Background())for i := 0; i < 10; i++ {_ = postStream.Send(&proto.StreamReqData{Data: fmt.Sprintf("客户端流模式 + %d", i)})time.Sleep(time.Second)}// 双向流模式allStream, _ := c.AllStream(context.Background())wg := sync.WaitGroup{}wg.Add(2)go func() { // 负责receivedefer wg.Done()for {recv, _ := allStream.Recv()fmt.Println("收到服务器消息：", recv.Data)}}()go func() {defer wg.Done()for i := 0; i < 10; i++ {allStream.Send(&proto.StreamReqData{Data: "我是客户端"})time.Sleep(time.Second)}}()wg.Wait()}

protobuf知识汇总

基本类型会有对应

一个标量消息字段可以含有一个如下的类型——该表格展示了定义于.proto文件中的类型，以及与之对应的、在自动生成的访问类中定义的类型：

.proto TypeNotesPython TypeGo Type
doublefloatfloat64
floatfloatfloat32
int32使用变长编码，对于负值的效率很低，如果你的域有可能有负值，请使用sint64替代intint32
uint32使用变长编码intuint32
uint64使用变长编码intuint64
sint32使用变长编码，这些编码在负值时比int32高效的多intint32
sint64使用变长编码，有符号的整型值。编码时比通常的int64高效。intint64
fixed32总是4个字节，如果数值总是比总是比228大的话，这个类型会比uint32高效。intuint32
fixed64总是8个字节，如果数值总是比总是比256大的话，这个类型会比uint64高效。intuint64
sfixed32总是4个字节intint32
sfixed64总是8个字节intint64
boolboolbool
string一个字符串必须是UTF-8编码或者7-bit ASCII编码的文本。strstring
bytes可能包含任意顺序的字节数据。str[]byte

protobuf是会有一个默认值，即使不传，也会有默认值

当一个消息被解析的时候，如果被编码的信息不包含一个特定的singular元素，被解析的对象锁对应的域被设置位一个默认值，对于不同类型指定如下：

  • 对于strings，默认是一个空string
  • 对于bytes，默认是一个空的bytes
  • 对于bools，默认是false
  • 对于数值类型，默认是0
  • 对于枚举，默认是第一个定义的枚举值，必须为0;
  • 对于消息类型（message），域没有被设置，确切的消息是根据语言确定的，详见generated code guide

使用repeated创建数组并使用python传递

client.py

# 方式1
with grpc.insecure_channel("localhost:8080") as channel:stub = helloword_pb2_grpc.GreeterStub(channel)hello_request = helloword_pb2.HelloRequest(id=[1, 2, 3,])  # 先实例化不赋值hello_request.name = "bob"res: helloword_pb2.HelloReply = stub.SayHello(hello_request)print(res.message)# 方式2
with grpc.insecure_channel("localhost:8080") as channel:stub = helloword_pb2_grpc.GreeterStub(channel)hello_request = helloword_pb2.HelloRequest()  # 先实例化不赋值hello_request.name = "bob"hello_request.id.extend([1, 2])  # 这个对象已经有默认值创建好了，我们把他当做一个list来进行操作hello_request.id.append(4)res: helloword_pb2.HelloReply = stub.SayHello(hello_request)print(res.message)

嵌套message定义的使用

// The response message containing the greetings
message HelloReply {string message = 1;message Result { // 在里面定义messagestring name = 1;string url = 2;}repeated Result data = 2; // 定义一个message数组
}

py中的嵌套调用：

from grpc_hello.proto.helloword_pb2 import HelloReply  #  使用嵌套里面的数据res = HelloReply.Result()
# 从哪嵌套的从哪调用

go中的嵌套调用：

import "GoRpc_quick/grpc_test/proto"proto.Pong{} // 直接调用

map与enum枚举类型等其他类型

// 使用枚举类型，使得类型只能是下面的某一个
enum Gender{MALE = 0;FEMALE = 1;
}// The request message containing the user's name.
message HelloRequest {string name = 1;string url = 2;Gender g = 3;map<string, string> mp = 4;google.protobuf.Timestamp addTime = 5; // 时间戳
}

python grpc配合asynio使用

现在已经有官方的api了https://grpc.github.io/grpc/python/grpc_asyncio.html

这里使用grpclib库来实现：

安装依赖包

pip install grpclib# 生成对应文件
python -m grpc_tools.protoc -I. --python_out=. --grpclib_python_out=. helloworld.proto

go-metadata

go中使用metadata

metadata使得client和server能够为对方提供关于本次调用的一些信息，就像一次http请求的RequestHeader和ResponseHeader一样。http中header的生命周周期是一次http请求，那么metadata的生命周期就是一次RPC调用

1. 新建metadata

MD 类型实际上是map，key是string，value是string类型的slice。

type MD map[string][]string

创建的时候可以像创建普通的map类型一样使用new关键字进行创建：

//第一种方式
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", // 使用逗号
)
2. 发送metadata
md := metadata.Pairs("key", "val")// 新建一个有 metadata 的 context
ctx := metadata.NewOutgoingContext(context.Background(), md)// 单向 RPC
response, err := client.SomeRPC(ctx, someRequest)
3. 接收metadata
func (s *server) SomeRPC(ctx context.Context, in *pb.SomeRequest) (*pb.SomeResponse, err) {md, ok := metadata.FromIncomingContext(ctx)// do something with metadata
}

2. grpc中使用metadata

proro

syntax = "proto3";
option go_package = ".;proto";// The greeting service definition.
service Greeter {// Sends a greeting 下面就是暴露出来的一些方法rpc SayHello (HelloRequest) returns (HelloReply) {} // 定义返回什么类型就要返回什么类型
}// The request message containing the user's name.
message HelloRequest {string name = 1;
}// The response message containing the greetings
message HelloReply {string message = 1;
}

server.go

type Server struct {*proto.UnimplementedGreeterServer
}// 参数设置是硬性规定的
func (s *Server) SayHello(ctx context.Context, req *proto.HelloRequest) (*proto.HelloReply, error) {md, ok := metadata.FromIncomingContext(ctx)if !ok {fmt.Println("get metadata error")}// 遍历一下这个string的mapfor k, v := range md {fmt.Println(k, v)}if nameSlice, ok := md["name"]; ok { // 判断map中是否含有元素fmt.Println(nameSlice)for i, e := range nameSlice {fmt.Println(i, e)}}return &proto.HelloReply{Message: "Go hello " + req.Name,}, nil
}func main() {// 一样的新建serverg := grpc.NewServer()// 注册服务proto.RegisterGreeterServer(g, &Server{})listen, err := net.Listen("tcp", "0.0.0.0:8080")if err != nil {panic("failed to listen: " + err.Error())}err = g.Serve(listen)if err != nil {panic("failed to start grpc: " + err.Error())}
}

client.go

func main() {conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())if err != nil {panic(err)}defer conn.Close()c := proto_bak.NewGreeterClient(conn)//md := metadata.Pairs("timestamp", time.Now().Format(times))md := metadata.New(map[string]string{"name": "alice","pwd":  "12345",})ctx := metadata.NewOutgoingContext(context.Background(), md)r, err := c.SayHello(ctx, &proto_bak.HelloRequest{Name: "bob",})if err != nil {panic(err)}fmt.Println(r.Message)}

python-meta

server.py

import grpcfrom grpc_metadata_test.proto import helloword_pb2, helloword_pb2_grpcif __name__ == '__main__':with grpc.insecure_channel("localhost:50051") as channel:stub = helloword_pb2_grpc.GreeterStub(channel)hello_request = helloword_pb2.HelloRequest()  # 先实例化不赋值hello_request.name = "bob"rsp, call = stub.SayHello.with_call(hello_request,metadata=(('name', 'bobby'),('pwd', '123456')))# call 能拿到服务器发回来的东西print(rsp.message)

client.py

import grpc
from concurrent import futures
from grpc_metadata_test.proto import helloword_pb2, helloword_pb2_grpcclass Greeter(helloword_pb2_grpc.GreeterServicer):def SayHello(self, request, context):# 一样的遍历metadata的mapfor k, v in context.invocation_metadata():print(k, v)return helloword_pb2.HelloReply(message=f'Python 你好{request.name}')if __name__ == '__main__':# 1. 实例化serverserver = grpc.server(futures.ThreadPoolExecutor(max_workers=10))  # 设置十个线程# 2. 注册逻辑到server中helloword_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)# 3. 启动serverserver.add_insecure_port('[::]:50051')server.start()server.wait_for_termination()

拦截器

go拦截器

server.go

type Server struct {*proto.UnimplementedGreeterServer
}// 参数设置是硬性规定的
func (s *Server) SayHello(ctx context.Context, req *proto.HelloRequest) (*proto.HelloReply, error) {return &proto.HelloReply{Message: "Go hello " + req.Name,}, nil
}func main() {// 定义拦截器的函数interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {fmt.Println("接收到了一个新的清秀")res, err := handler(ctx, req) // handler是原本的调用逻辑fmt.Println("请求已经完成")return res, err}opt := grpc.UnaryInterceptor(interceptor) // 参数是一个函数，所以参数必须一致（go认参数来区分函数// 一样的新建serverg := grpc.NewServer(opt) // 放进去// 注册服务proto.RegisterGreeterServer(g, &Server{})listen, err := net.Listen("tcp", "0.0.0.0:8080")if err != nil {panic("failed to listen: " + err.Error())}err = g.Serve(listen)if err != nil {panic("failed to start grpc: " + err.Error())}
}

client.go

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()err := invoker(ctx, method, req, reply, cc, opts...)fmt.Printf("耗时: %s\n", time.Since(start))return err} // 拦截器逻辑opt := grpc.WithUnaryInterceptor(interceptor) // 需要在dial（拨号）的时候传入参数conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure(), opt)if err != nil {panic(err)}defer conn.Close()c := proto.NewGreeterClient(conn)r, err := c.SayHello(context.Background(), &proto.HelloRequest{Name: "bob",})if err != nil {panic(err)}fmt.Println(r.Message)}

python拦截器

server.py

class Greeter(helloword_pb2_grpc.GreeterServicer):def SayHello(self, request, context):for k, v in context.invocation_metadata():print(k, v)return helloword_pb2.HelloReply(message=f'Python 你好{request.name}')# 调用拦截器逻辑需要继承该抽象类，并且实现这个抽象类的方法
class LogInterceptors(grpc.ServerInterceptor):def intercept_service(self, continuation, handler_call_details):print("请求开始")print(type(handler_call_details))rsp = continuation(handler_call_details)  # 相当于handlerprint("请求结束")return rspif __name__ == '__main__':# 实例化一个interinterceptor = LogInterceptors()# 1. 实例化serverserver = grpc.server(futures.ThreadPoolExecutor(max_workers=10), interceptors=(interceptor,))  # 设置十个线程# 并传进去interceptor的tuple或者list， 最后一定要带个，# 2. 注册逻辑到server中helloword_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)# 3. 启动serverserver.add_insecure_port('[::]:50051')server.start()server.wait_for_termination()

client.py

客户端的拦截器

# 第二个参数需要继承重写
class DefaultInterceptor(grpc.UnaryUnaryClientInterceptor):def intercept_unary_unary(self, continuation, client_call_details, request):# 拦截器业务逻辑start = datetime.now()rsp = continuation(client_call_details, request)print((datetime.now() - start).microseconds / 1000, "ms")return rspif __name__ == '__main__':# 实例化对象default_intercept = DefaultInterceptor()with grpc.insecure_channel("localhost:50051") as channel:# 需要对channel进行操作intercept_channel = grpc.intercept_channel(channel, default_intercept)stub = helloword_pb2_grpc.GreeterStub(intercept_channel)hello_request = helloword_pb2.HelloRequest()  # 先实例化不赋值hello_request.name = "bob"rsp, call = stub.SayHello.with_call(hello_request,metadata=(('name', 'bobby'),('pwd', '123456')))# call 能拿到服务器发回来的东西print(rsp.message)

验证器

docs：protoc-gen-validate/docs.md at main · bufbuild/protoc-gen-validate · GitHub

每个字段要满足一个验证规则

编译命令：

protoc \-I . \-I path/to/validate/ \--go_out=":../generated" \--validate_out="lang=go:../generated" \example.protoprotoc -I . --go_out=. --go-grpc_out=. --validate_out="lang=go:." ./hello.proto

需要去拷贝一份validate.proto放到文件中：protoc-gen-validate/validate/validate.proto at main · bufbuild/protoc-gen-validate · GitHub

proto

syntax = "proto3";import "validate.proto";
option go_package=".;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:   "^(?:(?:\\+|00)86)?1[3-9]\\d{9}$",max_bytes: 256,}];}

server.go

package mainimport ("context""google.golang.org/grpc/codes""google.golang.org/grpc/status""net""google.golang.org/grpc""GoRpc_quick/grpc_validate_test/proto"
)type Server struct {*proto.UnimplementedGreeterServer
}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() {//p := new(proto.Person)//p.Id = 1000//err := p.Validate() // 会返回一个error来判断合法性//if err != nil {// panic(err)//}var interceptor grpc.UnaryServerInterceptorinterceptor = func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {// 在拦截器中判断完整性，继续处理请求if r, ok := req.(Validator); ok { // 实例化为Validator，用多态的方法调用Validate方法if err := r.Validate(); err != nil {return nil, status.Error(codes.InvalidArgument, err.Error())}}return handler(ctx, req)}var opts []grpc.ServerOptionopts = 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.go

package mainimport ("GoRpc_quick/grpc_validate_test/proto""context""fmt""google.golang.org/grpc"
)// 本质上封装了metadata的封装
type customCredential struct {
}func main() {var opts []grpc.DialOptionopts = append(opts, grpc.WithInsecure())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.Person{Id:     1000,Email:  "1234abc@qq.com",Mobile: "18888888888",})if err != nil {panic(err)}fmt.Println(r.Id)}

错误处理与超时设定

python

客户端处理：

import grpc
from grpc_error_test.proto import helloword_pb2, helloword_pb2_grpcif __name__ == '__main__':with grpc.insecure_channel("localhost:8080") as channel:stub = helloword_pb2_grpc.GreeterStub(channel)hello_request = helloword_pb2.HelloRequest()  # 先实例化不赋值hello_request.name = "bob"try:res: helloword_pb2.HelloReply = stub.SayHello(hello_request, timeout=3)except grpc.RpcError as e:d = e.details()print(d)status_code = e.code() # 获取codeprint(status_code.name)print(status_code.value)print(res.message)

服务端处理

import grpc
from concurrent import futures
from grpc_error_test.proto import helloword_pb2, helloword_pb2_grpcclass Greeter(helloword_pb2_grpc.GreeterServicer):def SayHello(self, request, context):context.set_code(grpc.StatusCode.NOT_FOUND)context.set_details("记录不存在")return helloword_pb2.HelloReply(message=f'Python 你好{request.name}')if __name__ == '__main__':# 1. 实例化serverserver = grpc.server(futures.ThreadPoolExecutor(max_workers=10))  # 设置十个线程# 2. 注册逻辑到server中helloword_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)# 3. 启动serverserver.add_insecure_port('[::]:8080')server.start()server.wait_for_termination()

Go

客户端处理

func main() {conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())if err != nil {panic(err)}defer conn.Close()c := proto.NewGreeterClient(conn)// 设置3超时ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)defer cancel()_, err = c.SayHello(ctx, &proto.HelloRequest{Name: "bob",})if err != nil { // 捕捉并解析错误st, ok := status.FromError(err)if !ok {panic("error解析失败")}fmt.Println(st.Message())fmt.Println(st.Code())}//fmt.Println(r.Message)}

服务端处理：

package mainimport ("GoRpc_quick/grpc_error_test/proto""context""google.golang.org/grpc""google.golang.org/grpc/codes""google.golang.org/grpc/status""net"
)type Server struct {*proto.UnimplementedGreeterServer
}// 参数设置是硬性规定的
func (s *Server) SayHello(ctx context.Context, req *proto.HelloRequest) (*proto.HelloReply, error) {return &proto.HelloReply{Message: "Go hello " + req.Name,}, status.Error(codes.InvalidArgument, "未实现") // 返回错误码和描述
}func main() {// 一样的新建serverg := grpc.NewServer()// 注册服务proto.RegisterGreeterServer(g, &Server{})listen, err := net.Listen("tcp", "0.0.0.0:8080")if err != nil {panic("failed to listen: " + err.Error())}err = g.Serve(listen)if err != nil {panic("failed to start grpc: " + err.Error())}
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

1024 云上见 · 上云挑战（ChatGPT搭建）

1024 云上见 · 上云挑战（ChatGPT搭建）

【玩转1024】使用函数计算X通义千问搭建AI助手&#xff0c;参与1024小说创作大赛 【使用函数计算X通义千问搭建AI助手&#xff0c;参与小说创作大赛】&#xff1a;本活动基于函数计算X 通义千问快速部署 AI 个人助手应用&#xff0c;用户可以根据需要选择不同角色的AI助手开启…
阅读更多...
Maven配置阿里云中央仓库settings.xml

Maven配置阿里云中央仓库settings.xml

Maven配置阿里云settings.xml 前言一、阿里云settings.xml二、使用步骤1.任意目录创建settings.xml2.使用阿里云仓库 总结 前言 国内网络从maven中央仓库下载文件通常是比较慢的&#xff0c;所以建议配置阿里云代理镜像以提高jar包下载速度&#xff0c;IDEA中我们需要配置自己…
阅读更多...
基础课13——数据异常处理

基础课13——数据异常处理

数据异常是指数据不符合预期或不符合常识的情况。数据异常可能会导致数据分析结果不准确&#xff0c;甚至是错误&#xff0c;因此在进行数据分析之前需要对数据进行清洗和验证。 常见的数据异常包括缺失值、重复值、异常值等。 缺失值是指数据中存在未知值或未定义的值&#…
阅读更多...
k8s集群环境搭建

k8s集群环境搭建

简介&#xff1a; 以工作项目的视角来讲解k8s相关环境搭建&#xff0c;提供k8s相关基础理论、测试案例&#xff0c;极大方便k8s的入门、进阶 k8s入门之前&#xff0c;集群环境的搭建是至关重要的&#xff0c;有了集群环境&#xff0c;才方便后续k8s的学习和实践。但集群的搭建…
阅读更多...
JAVA：集合框架常见的面试题和答案

JAVA：集合框架常见的面试题和答案

1、List接口的常见实现类有哪些&#xff1f; 答&#xff1a; 常见的List接口实现类包括&#xff1a; ArrayList: 基于动态数组实现的List&#xff0c;支持快速随机访问。LinkedList: 基于链表实现的List&#xff0c;支持快速的插入和删除操作。Vector: 一个线程安全的动态数组…
阅读更多...
Kotlin基础——枚举、When、in、for

Kotlin基础——枚举、When、in、for

枚举 声明只有值的枚举 enum class Color {RED, GREEN, BLUE }此外还可以增加属性和方法&#xff0c;如果需要在枚举类中定义方法&#xff0c;要使用分号把枚举常量列表和方法定义分开&#xff0c;这也是Kotlin唯一必须使用分号的地方 enum class Color(val r: Int, val g: …
阅读更多...
基于Java的流浪动物救助管理系统设计与实现(源码+lw+部署文档+讲解等)

基于Java的流浪动物救助管理系统设计与实现(源码+lw+部署文档+讲解等)

文章目录 前言具体实现截图论文参考详细视频演示为什么选择我自己的网站自己的小程序&#xff08;小蔡coding&#xff09; 代码参考数据库参考源码获取 前言 &#x1f497;博主介绍&#xff1a;✌全网粉丝10W,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域优质创作者&am…
阅读更多...
ROS自学笔记十七：Arbotix

ROS自学笔记十七：Arbotix

ArbotiX 是一个基于 ROS&#xff08;Robot Operating System&#xff09;的机器人控制系统&#xff0c;它旨在为小型机器人提供硬件控制和传感器接口&#xff0c;以便于机器人的运动和感知。以下是有关 ROS 中 ArbotiX 的简介和安装步骤&#xff1a; ArbotiX 简介 ArbotiX 主…
阅读更多...
vue3使用ref和reactive

vue3使用ref和reactive

Vue 3引入了两个新的API&#xff0c;ref和reactive&#xff0c;用于创建响应式对象。这两个方法都位于Vue.prototype上&#xff0c;因此可以在组件实例中直接使用。 ref ref函数用于创建一个响应式引用对象。这个函数可以接受一个普通的变量或对象作为参数&#xff0c;并返回…
阅读更多...
Qt中实现页面切换的两种方式

Qt中实现页面切换的两种方式

文章目录 方式一 &#xff1a;使用QStackedWidget讲解代码结构main.cpp完整代码运行结果&#xff1a; 方式二 &#xff1a;代码结构完整代码mainwindow.hnewmainwindow.hmain.cppmainwindow.cppnewmainwindow.cppmainwindow.uinewmainwindow.ui 效果 方式一 &#xff1a;使用QS…
阅读更多...
docker 部署 若依 Ruoyi springboot+vue分离版 dockerCompose

docker 部署 若依 Ruoyi springboot+vue分离版 dockerCompose

本篇从已有虚拟机/服务器 安装好dokcer为基础开始讲解 1.部署mysql 创建conf data init三个文件夹 conf目录存放在mysql配置文件 init目录存放着若依数据库sql文件&#xff08;从navicat导出的并非若依框架自带sql&#xff09; 创建一个属于本次若依部署的网段&#xff08;只…
阅读更多...
探秘JVM虚拟机中的堆、栈和方法区：内存世界的三位重要角色

探秘JVM虚拟机中的堆、栈和方法区：内存世界的三位重要角色

在Java编程中&#xff0c;我们经常听到关于JVM&#xff08;Java虚拟机&#xff09;的概念。JVM是Java程序运行的核心&#xff0c;负责将Java源代码翻译成机器语言并执行。而JVM中的堆、栈和方法区则是内存管理的重要组成部分。本文将带您深入了解JVM虚拟机中这三个角色的关系&a…
阅读更多...
Redis快速上手篇七(集群-分布式锁)

Redis快速上手篇七(集群-分布式锁)

分布式锁 随着业务发展的需要&#xff0c;原单体单机部署的系统被演化成分布式集群系统后&#xff0c;由于分布式系统多线程、多进程并且分布在不同机器上&#xff0c;这将使原单机部署情况下的并发控制锁策略失效。 单纯的Java API并不能提供分布式锁的能力。为了解决这个问…
阅读更多...
设置GIT代理

设置GIT代理

前言 很多同学在使用Git拉取代码被网络限制&#xff0c;速度很慢&#xff0c;本文给大家介绍如何给Git设置代理访问。 大家先自行准备好该有的代理 注意&#xff1a; 以下示例代码的端口要根据自己实际代理端口。 设置全局代理 git config --global http.proxy socks5://127…
阅读更多...
sql-50练习题6-10

sql-50练习题6-10

sql练习题6-10题 前言数据库表结构介绍学生表课程表成绩表教师表 0-6 查询"李"姓老师的数量0-7 查询学过"李四"老师授课的同学的信息0-8 查询没学过"李四"老师授课的同学的信息0-9 查询学过编号为"01"并且也学过编号为"02"的…
阅读更多...
前端性别判断

前端性别判断

<input type"radio" v-model"users.sex" value"1">男 <input type"radio" v-model"users.sex" value"0">女 这是一段HTML代码&#xff0c;用于创建两个单选按钮。这些单选按钮使用了Vue.js的v-mode…
阅读更多...
外部中断0边沿触发

外部中断0边沿触发

/*----------------------------------------------- 内容&#xff1a;通过中断接口P3.2连接的独立按键测试&#xff0c;按一次P1口的LED灯反向&#xff0c; 这里使用边沿触发&#xff0c;所以一直按键不松开和一次按键效果相同&#xff0c;区 别于电平触发 --…
阅读更多...
Redis（09）| Reactor模式

Redis（09）| Reactor模式

我们在使用Redis的时候&#xff0c;通常是多个客户端连接Redis服务器&#xff0c;然后各自发送命令请求(例如Get、Set)到Redis服务器&#xff0c;最后Redis处理这些请求返回结果。 从上一篇博文《Redis&#xff08;08&#xff09;| 线程模型》中知道Redis是单线程。Redis除了处…
阅读更多...
数据结构——栈与队列

数据结构——栈与队列

目录 1. 中缀表达式转换为后缀表达式 2. 括号匹配问题 3. 栈实现队列 4. 约瑟夫环 1. 中缀表达式转换为后缀表达式 【问题描述】 输入一个中缀表达式&#xff0c;表达式中有、-、*、/四种运算以及&#xff08;、&#xff09;&#xff0c;表达式中的其他符号为大写的字母。实…
阅读更多...
持续集成部署-k8s-服务发现-Ingress

持续集成部署-k8s-服务发现-Ingress

持续集成部署-k8s-服务发现-Ingress 1. Ingress 是什么2. Ingress 控制器3. 安装 Ingress-Nginx3.1 添加 Helm 仓库3.2 更新 Helm 仓库3.3 下载 Ingress-Nginx 安装包3.4 配置 Ingress-Nginx 配置文件参数3.5 安装 Ingress-Nginx1. Ingress 是什么 Ingress是 Kubernetes 中的一…
阅读更多...
最新文章

Copyright @ 2022~2023