【Go】五、Grpc 的入门使用

grpc 与 protobuf

grpc 使用的是 protobuf 协议，其是一个通用的 rpc 框架，基本支持主流的所有语言、其底层使用 http/2 进行网络通信，具有较高的效率

protobuf 是一种序列化格式，这种格式具有 序列化以及解码速度快（对比json、xml 速度快 2 - 100 倍），压缩率高等优点，是一个性能炸弹

基础环境配置

我们使用之前，要先安装 protobuf 的相关环境：

在 github 上下载 protoc 并配置好环境变量（环境变量配置到 bin 这一级）（用来生成源码）

记得在编译器中安装 protobuf support 插件

protobuf尝试

对 protobuf 进行尝试：创建一个.proto 文件：

syntax = "proto3";message HelloRequest {string name = 1;  // 注意这里不是赋值，而是指定编号
}

之后使用 protoc 生成源码

protoc -I . --go_out=. --go-grpc_out=require_unimplemented_servers=false:. ./helloworld.proto

测试proto的使用：

func main() {req := HelloWorld.HelloRequest{Name:    "Chen",Age:     16,Courses: []string{"C", "Go"},}rsp, _ := proto.Marshal(&req)       // 编码newReq := HelloWorld.HelloRequest{} // 创建一个空的proto_ = proto.Unmarshal(rsp, &newReq)   // 解码，解码存储在 newReq 中fmt.Println(newReq.Name, newReq.Age, newReq.Courses)
}

实际开发尝试

创建目录结构：

grpc_test

server

server.go

client

proto

helloworld.proto

helloworld.pb.go（自动生成）

helloworld_grpc.pb.go（自动生成）

首先自己编写 helloworld.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 -I . --go_out=. --go-grpc_out=require_unimplemented_servers=false:. ./helloworld.proto

生成helloworld.pb.go 文件：

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.32.0
// 	protoc        v4.25.3
// source: helloworld.protopackage protoimport (protoreflect "google.golang.org/protobuf/reflect/protoreflect"protoimpl "google.golang.org/protobuf/runtime/protoimpl"reflect "reflect"sync "sync"
)const (// Verify that this generated code is sufficiently up-to-date._ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)// Verify that runtime/protoimpl is sufficiently up-to-date._ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)type HelloRequest struct {state         protoimpl.MessageStatesizeCache     protoimpl.SizeCacheunknownFields protoimpl.UnknownFieldsName string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}func (x *HelloRequest) Reset() {*x = HelloRequest{}if protoimpl.UnsafeEnabled {mi := &file_helloworld_proto_msgTypes[0]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}
}func (x *HelloRequest) String() string {return protoimpl.X.MessageStringOf(x)
}func (*HelloRequest) ProtoMessage() {}func (x *HelloRequest) ProtoReflect() protoreflect.Message {mi := &file_helloworld_proto_msgTypes[0]if protoimpl.UnsafeEnabled && x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {ms.StoreMessageInfo(mi)}return ms}return mi.MessageOf(x)
}// Deprecated: Use HelloRequest.ProtoReflect.Descriptor instead.
func (*HelloRequest) Descriptor() ([]byte, []int) {return file_helloworld_proto_rawDescGZIP(), []int{0}
}func (x *HelloRequest) GetName() string {if x != nil {return x.Name}return ""
}type HelloReply struct {state         protoimpl.MessageStatesizeCache     protoimpl.SizeCacheunknownFields protoimpl.UnknownFieldsMessage string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}func (x *HelloReply) Reset() {*x = HelloReply{}if protoimpl.UnsafeEnabled {mi := &file_helloworld_proto_msgTypes[1]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}
}func (x *HelloReply) String() string {return protoimpl.X.MessageStringOf(x)
}func (*HelloReply) ProtoMessage() {}func (x *HelloReply) ProtoReflect() protoreflect.Message {mi := &file_helloworld_proto_msgTypes[1]if protoimpl.UnsafeEnabled && x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {ms.StoreMessageInfo(mi)}return ms}return mi.MessageOf(x)
}// Deprecated: Use HelloReply.ProtoReflect.Descriptor instead.
func (*HelloReply) Descriptor() ([]byte, []int) {return file_helloworld_proto_rawDescGZIP(), []int{1}
}func (x *HelloReply) GetMessage() string {if x != nil {return x.Message}return ""
}var File_helloworld_proto protoreflect.FileDescriptorvar file_helloworld_proto_rawDesc = []byte{0x0a, 0x10, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x2e, 0x70, 0x72, 0x6f,0x74, 0x6f, 0x22, 0x22, 0x0a, 0x0c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65,0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x26, 0x0a, 0x0a, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52,0x65, 0x70, 0x6c, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x31,0x0a, 0x07, 0x47, 0x72, 0x65, 0x65, 0x74, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x08, 0x53, 0x61, 0x79,0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x12, 0x0d, 0x2e, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x65, 0x71,0x75, 0x65, 0x73, 0x74, 0x1a, 0x0b, 0x2e, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x65, 0x70, 0x6c,0x79, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x3b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72,0x6f, 0x74, 0x6f, 0x33,
}var (file_helloworld_proto_rawDescOnce sync.Oncefile_helloworld_proto_rawDescData = file_helloworld_proto_rawDesc
)func file_helloworld_proto_rawDescGZIP() []byte {file_helloworld_proto_rawDescOnce.Do(func() {file_helloworld_proto_rawDescData = protoimpl.X.CompressGZIP(file_helloworld_proto_rawDescData)})return file_helloworld_proto_rawDescData
}var file_helloworld_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_helloworld_proto_goTypes = []interface{}{(*HelloRequest)(nil), // 0: HelloRequest(*HelloReply)(nil),   // 1: HelloReply
}
var file_helloworld_proto_depIdxs = []int32{0, // 0: Greeter.SayHello:input_type -> HelloRequest1, // 1: Greeter.SayHello:output_type -> HelloReply1, // [1:2] is the sub-list for method output_type0, // [0:1] is the sub-list for method input_type0, // [0:0] is the sub-list for extension type_name0, // [0:0] is the sub-list for extension extendee0, // [0:0] is the sub-list for field type_name
}func init() { file_helloworld_proto_init() }
func file_helloworld_proto_init() {if File_helloworld_proto != nil {return}if !protoimpl.UnsafeEnabled {file_helloworld_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {switch v := v.(*HelloRequest); i {case 0:return &v.statecase 1:return &v.sizeCachecase 2:return &v.unknownFieldsdefault:return nil}}file_helloworld_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {switch v := v.(*HelloReply); i {case 0:return &v.statecase 1:return &v.sizeCachecase 2:return &v.unknownFieldsdefault:return nil}}}type x struct{}out := protoimpl.TypeBuilder{File: protoimpl.DescBuilder{GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: file_helloworld_proto_rawDesc,NumEnums:      0,NumMessages:   2,NumExtensions: 0,NumServices:   1,},GoTypes:           file_helloworld_proto_goTypes,DependencyIndexes: file_helloworld_proto_depIdxs,MessageInfos:      file_helloworld_proto_msgTypes,}.Build()File_helloworld_proto = out.Filefile_helloworld_proto_rawDesc = nilfile_helloworld_proto_goTypes = nilfile_helloworld_proto_depIdxs = nil
}

以及：

helloworld_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.25.3
// source: helloworld.protopackage protoimport (context "context"grpc "google.golang.org/grpc"codes "google.golang.org/grpc/codes"status "google.golang.org/grpc/status"
)// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7const (Greeter_SayHello_FullMethodName = "/Greeter/SayHello"
)// GreeterClient is the client API for Greeter service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type GreeterClient interface {SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
}type greeterClient struct {cc grpc.ClientConnInterface
}func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {return &greeterClient{cc}
}func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {out := new(HelloReply)err := c.cc.Invoke(ctx, Greeter_SayHello_FullMethodName, in, out, opts...)if err != nil {return nil, err}return out, nil
}// GreeterServer is the server API for Greeter service.
// All implementations should embed UnimplementedGreeterServer
// for forward compatibility
type GreeterServer interface {SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}// UnimplementedGreeterServer should be embedded to have forward compatible implementations.
type UnimplementedGreeterServer struct {
}func (UnimplementedGreeterServer) SayHello(context.Context, *HelloRequest) (*HelloReply, error) {return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
}// UnsafeGreeterServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GreeterServer will
// result in compilation errors.
type UnsafeGreeterServer interface {mustEmbedUnimplementedGreeterServer()
}func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {s.RegisterService(&Greeter_ServiceDesc, srv)
}func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {in := new(HelloRequest)if err := dec(in); err != nil {return nil, err}if interceptor == nil {return srv.(GreeterServer).SayHello(ctx, in)}info := &grpc.UnaryServerInfo{Server:     srv,FullMethod: Greeter_SayHello_FullMethodName,}handler := func(ctx context.Context, req interface{}) (interface{}, error) {return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))}return interceptor(ctx, in, info, handler)
}// Greeter_ServiceDesc is the grpc.ServiceDesc for Greeter service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Greeter_ServiceDesc = grpc.ServiceDesc{ServiceName: "Greeter",HandlerType: (*GreeterServer)(nil),Methods: []grpc.MethodDesc{{MethodName: "SayHello",Handler:    _Greeter_SayHello_Handler,},},Streams:  []grpc.StreamDesc{},Metadata: "helloworld.proto",
}

尝试编写业务逻辑（这里应该写在handler中，由于业务过于简单，先写在server中）：

server.go：

注意这里 grpc 帮我们处理了服务器不能连续被访问的问题，不需要我们手动通过一个死循环进行处理

package mainimport ("context""net""google.golang.org/grpc""FirstGo/goon/grpc_test/proto"
)type Server struct{}// 业务逻辑
// 第一个参数必须是context，error必须加
func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply, error) {return &proto.HelloReply{Message: "hello " + request.Name,}, nil
}func main() {g := grpc.NewServer()proto.RegisterGreeterServer(g, &Server{})lis, err := net.Listen("tcp", "0.0.0.0:8080")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 ("FirstGo/goon/grpc_test/proto""context""fmt""google.golang.org/grpc"
)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)// 调用对应的方法r, err := c.SayHello(context.Background(), &proto.HelloRequest{Name: "Chen"})if err != nil {panic(err)}fmt.Println(r.Message)
}

GRPC的四种数据传输模式

RPC 还具有四种数据模式，其分别是：

  1. 简单模式（上述模式）

    客户端发起一次请求，服务器返回一次响应

  2. 服务端数据流模式

    客户发起一次请求，服务器返回一段连续的数据流，最典型的例子是：客户发送一段股票代码，服务端实时将股票的数据源源不断的返回给客户端

  3. 客户端数据流模式

    与服务端数据流模式相反，这种是由客户端源源不断的向服务端发送数据流，在发送结束后，由服务端发送一个响应，这种的典型例子是：物联网终端向服务器报送数据

  4. 双向数据流模式

    这种是客户端和服务端都可以向双方发送数据流，这个时候双方的数据都可以相互发送，也就是可以实时交互，这种最典型的例子就是聊天机器人

实际测试：
建立文件结构：

stream_grpc_test

server

server.go

client

client.go

proto

stream.pb.gp

stream.proto

stream_grpc.pb.go

stream.proto：

syntax = "proto3";option go_package = ".;proto";service Greeter {rpc GetStream(StreamReqData) returns (stream StreamResData);  //  服务端流模式，返回的响应数据是流rpc PutStream(stream StreamReqData) returns (StreamResData);  // 客户端流模式，传给服务器的数据是流rpc AllStream(stream StreamReqData) returns (stream StreamResData);   // 双向流模式
}message StreamReqData {string data = 1;
}message StreamResData {string data = 1;
}

服务端流模式简单使用

只写了 服务端流模式的 server,go：

const PORT = ":50052"type server struct {
}// 对于服务端数据传输模式，参考以下内容：
// 没有 context 参数，而是将返回作为入参传入
func (s *server) GetStream(req *proto.StreamReqData, res proto.Greeter_GetStreamServer) error {i := 0for {i++_ = res.Send(&proto.StreamResData{Data: fmt.Sprintf("%v", time.Now().Unix()),})time.Sleep(time.Second)if i > 10 {break}}return nil
}// 客户端数据流模式
// 只有一个用来不断接收的入参
func (s *server) PutStream(cliStr proto.Greeter_PutStreamServer) error {return nil
}// 双向数据流模式，和客户端模式相同，只有一个入参
func (s *server) AllStream(allStr proto.Greeter_AllStreamServer) error {return nil
}func main() {lis, err := net.Listen("tcp", PORT)if err != nil {panic(err)}s := grpc.NewServer()proto.RegisterGreeterServer(s, &server{})s.Serve(lis)}

只针对于服务端流的client.go

func main() {// 拨号conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())if err != nil {panic(err)}defer conn.Close()c := proto.NewGreeterClient(conn)// 这里要注意：我们在进行调用的时候使用的仍让是 simple 的模式，而不是服务端的函数模式res, _ := c.GetStream(context.Background(), &proto.StreamReqData{Data: "Chen"})// 使用一个死循环来接收客户端传进来的数据for {a, err := res.Recv()if err != nil {fmt.Println(err)break}fmt.Println(a)}
}

客户端流模式的简单使用

server.go：

package mainimport ("FirstGo/goon/stream_grpc_test/proto""fmt""google.golang.org/grpc""net""time"
)const PORT = ":50052"type server struct {
}// 对于服务端数据传输模式，参考以下内容：
// 没有 context 参数，而是将返回作为入参传入
func (s *server) GetStream(req *proto.StreamReqData, res proto.Greeter_GetStreamServer) error {i := 0for {i++_ = res.Send(&proto.StreamResData{Data: fmt.Sprintf("%v", time.Now().Unix()),})time.Sleep(time.Second)if i > 10 {break}}return nil
}// 客户端数据流模式
// 只有一个用来不断接收的入参
func (s *server) PutStream(cliStr proto.Greeter_PutStreamServer) error {// 客户端流模式，客户端不断的发送数据给服务器for {if a, err := cliStr.Recv(); err != nil {fmt.Println(err)} else {fmt.Println(a.Data)}}return nil
}// 双向数据流模式，和客户端模式相同，只有一个入参
func (s *server) AllStream(allStr proto.Greeter_AllStreamServer) error {return nil
}func main() {lis, err := net.Listen("tcp", PORT)if err != nil {panic(err)}s := grpc.NewServer()proto.RegisterGreeterServer(s, &server{})s.Serve(lis)}

client.go：

package mainimport ("FirstGo/goon/stream_grpc_test/proto""context""fmt""google.golang.org/grpc""time"
)func main() {// 拨号conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())if err != nil {panic(err)}defer conn.Close()c := proto.NewGreeterClient(conn)putS, _ := c.PutStream(context.Background())i := 0for {i++putS.Send(&proto.StreamReqData{Data: fmt.Sprintf("Chen %d", i)})time.Sleep(time.Second)if i > 10 {break}}
}

双向流模式的简单使用

server.go：

package mainimport ("FirstGo/goon/stream_grpc_test/proto""fmt""google.golang.org/grpc""net""sync""time"
)const PORT = ":50052"type server struct {
}// 对于服务端数据传输模式，参考以下内容：
// 没有 context 参数，而是将返回作为入参传入
func (s *server) GetStream(req *proto.StreamReqData, res proto.Greeter_GetStreamServer) error {i := 0for {i++_ = res.Send(&proto.StreamResData{Data: fmt.Sprintf("%v", time.Now().Unix()),})time.Sleep(time.Second)if i > 10 {break}}return nil
}// 客户端数据流模式
// 只有一个用来不断接收的入参
func (s *server) PutStream(cliStr proto.Greeter_PutStreamServer) error {// 客户端流模式，客户端不断的发送数据给服务器for {if a, err := cliStr.Recv(); err != nil {fmt.Println(err)} else {fmt.Println(a.Data)}}return nil
}// 双向数据流模式，和客户端模式相同，只有一个入参
func (s *server) AllStream(allStr proto.Greeter_AllStreamServer) error {// 不可以像下面这样简单使用，因为 Recv() 会阻塞主线程//allStr.Recv()//allStr.Send()wg := sync.WaitGroup{}wg.Add(2) // 添加两个等待线程go func() {defer wg.Done()for {data, _ := allStr.Recv()fmt.Println("收到客户端消息：" + data.Data)}}()go func() {defer wg.Done()for {_ = allStr.Send(&proto.StreamResData{Data: "我是服务器"})time.Sleep(time.Second)}}()wg.Wait()return nil
}func main() {lis, err := net.Listen("tcp", PORT)if err != nil {panic(err)}s := grpc.NewServer()proto.RegisterGreeterServer(s, &server{})s.Serve(lis)}

client.go:

package mainimport ("FirstGo/goon/stream_grpc_test/proto""context""fmt""google.golang.org/grpc""sync""time"
)func main() {// 拨号conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())if err != nil {panic(err)}defer conn.Close()c := proto.NewGreeterClient(conn)// // 这里要注意：我们在进行调用的时候使用的仍让是 simple 的模式，而不是服务端的函数模式// 服务端模式的客户端//res, _ := c.GetStream(context.Background(), &proto.StreamReqData{Data: "Chen"})// // 使用一个死循环来接收客户端传进来的数据//for {//	a, err := res.Recv()//	if err != nil {//		fmt.Println(err)//		break//	}//	fmt.Println(a)//}// 客户端数据流模式//putS, _ := c.PutStream(context.Background())//i := 0//for {//	i++//	putS.Send(&proto.StreamReqData{Data: fmt.Sprintf("Chen %d", i)})//	time.Sleep(time.Second)//	if i > 10 {//		break//	}//}// 双向流模式allStr, _ := c.AllStream(context.Background())wg := sync.WaitGroup{}wg.Add(2) // 添加两个等待线程go func() {defer wg.Done()for {data, _ := allStr.Recv()fmt.Println("收到客户端消息：" + data.Data)}}()go func() {defer wg.Done()for {_ = allStr.Send(&proto.StreamReqData{Data: "我是Chen (客户端)"})time.Sleep(time.Second)}}()wg.Wait()
}

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

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

相关文章

MySQL的备份与恢复案例

MySQL的备份与恢复案例

新建数据库 数据库备份，数据库为school，素材如下1.创建student和score表CREATE TABLE student ( id INT(10) NOT NULL UNIQUE PRIMARY KEY , name VARCHAR(20) NOT NULL , sex VARCHAR(4) , birth YEAR, department VARCHAR(20) , address…
阅读更多...
Python3类变量

Python3类变量

诸神缄默不语-个人CSDN博文目录 在Python中，类变量是定义在类中且在函数体外的变量。类变量可以通过类本身或类的实例来访问。类变量分为三种类型：类属性、实例属性和局部变量。本文将分别介绍这三种类型的类变量，并通过简单易懂的代码示例进…
阅读更多...
打码半年，开源一款自定义大屏设计软件！

打码半年，开源一款自定义大屏设计软件！

hi，大家好，我是Tduck马马。 最近我们开源了一款大屏软件-TReport，与大家分享。 TReport是一款基于Vue3技术栈的数据可视化系统，支持静态、动态api等数据源；可用于数据可视化分析、报表分析、海报设计使用。 提供自定…
阅读更多...
leetcode hot100 分割等和子集

leetcode hot100 分割等和子集

在本题中，我们是要把一个数组，分割成两个子集，并且两个子集的元素和相等。那么也就是说，两个子集的和是相等的，并且都是整个数组的一半。那我们考虑这是一个01背包问题，物品的价值和物品的质量一样&#xf…
阅读更多...
linux 10 定时任务

linux 10 定时任务

作用: 计划任务主要是做一些周期性的任务， 目前最主要的用途是定期备份数据。 at命令的时间格式： 例子： crontab有系统级别的任务，用户的不放在这里 查看用户任务 或者用
阅读更多...
VSCODE使用Django

VSCODE使用Django

https://code.visualstudio.com/docs/python/tutorial-django#_use-a-template-to-render-a-page 通过模板渲染页面 HTML文件 实现步骤 1， 修改代码，hello的App名字增加到installed_apps表中。 2， hello子目录下，创建 .\templat…
阅读更多...
Unity【角色/摄像机移动控制】【3.摄像机跟随角色】

Unity【角色/摄像机移动控制】【3.摄像机跟随角色】

本章代码基于前两章。 1. 我们新建CameraController脚本，将其挂载到Camera上 2. 在角色Player下新建一个空物体，命名为cameraTargetPoint，并将该物体挂载至CameraController脚本中【注意代码中的这行：public Transform cameraTarg…
阅读更多...
二分算法02

二分算法02

二分算法02 1. 每个小孩最多能分到多少糖果2. 准时到达的列车最小时速3. 在 D 天内送达包裹的能力 1. 每个小孩最多能分到多少糖果 给你一个 下标从 0 开始 的整数数组 candies 。数组中的每个元素表示大小为 candies[i] 的一堆糖果。你可以将每堆糖果分成任意数量的 子堆 &am…
阅读更多...
一文搞懂LDO !

一文搞懂LDO !

7.LDO 1.原理 通过运放调节P-MOS的输出 低压差： 输出压降比较低，例如输入3.3V，输出可以达到3.2V。 线性： LDO内部的MOS管工作于线性状态。（可变电阻区） 稳压器： 说明了LDO的用途是用来给电…
阅读更多...
Panalog大数据日志审计系统libres_syn_delete.php存在命令执行漏洞

Panalog大数据日志审计系统libres_syn_delete.php存在命令执行漏洞

文章目录 前言声明一、Panalog大数据日志审计系统简介二、漏洞描述三、影响版本四、漏洞复现五、整改意见 前言 Panalog大数据日志审计系统定位于将大数据产品应用于高校、 公安、 政企、 医疗、 金融、 能源等行业之中，针对网络流量的信息进行日志留存&#xff0c…
阅读更多...
Maven(基础)、MyBatis

Maven(基础)、MyBatis

简介 Apache Maven是一个项目管理和构建工具，它基于项目对象模型 (POM)的概念，通过一小段描述信息来管理项目的构建、报告和文档 官网: http://maven.apache.org/ Maven作用 Maven是专门用于管理和构建Java项目的工具，它的主要功能有&#x…
阅读更多...
C语言——从头开始——深入理解指针（1）

C语言——从头开始——深入理解指针（1）

一.内存和地址 我们知道计算上CPU（中央处理器）在处理数据的时候，是通过地址总线把需要的数据从内存中读取的，后通过数据总线把处理后的数据放回内存中。如下图所示： 计算机把内存划分为⼀个个的内存单元，每…
阅读更多...
php使用get_browser()函数将移动端和pc端分开

php使用get_browser()函数将移动端和pc端分开

首先，确保你的PHP版本支持get_browser函数。get_browser函数是PHP内置的函数，但需要配置php.ini文件中的browscap参数，指定一个浏览器配置文件。 下载浏览器配置文件。你可以从 https://download.csdn.net/download/bigorange1/88850695 下…
阅读更多...
vulhub中Apache Log4j Server 反序列化命令执行漏洞复现（CVE-2017-5645）

vulhub中Apache Log4j Server 反序列化命令执行漏洞复现（CVE-2017-5645）

Apache Log4j是一个用于Java的日志记录库，其支持启动远程日志服务器。Apache Log4j 2.8.2之前的2.x版本中存在安全漏洞。攻击者可利用该漏洞执行任意代码。 1.我们使用ysoserial生成payload，然后直接发送给your-ip:4712端口即可。 java -jar ysoserial-…
阅读更多...
Python编程语言学习

Python编程语言学习

1.Python 特点 Python是一种简单、易读、易学和高效的编程语言，具有以下特点： 简单易学：Python采用清晰简洁的语法，注重代码的可读性和可维护性，使得初学者能够快速上手并编写出清晰的代码。 面向对象：Py…
阅读更多...
Android EditText关于imeOptions的设置和响应

Android EditText关于imeOptions的设置和响应

日常开发中，最绕不开的一个控件就是EditText，随之避免不了的则是对其软键盘事件的监听，随着需求的不同对用户输入的软键盘要求也不同，有的场景需要用户输入完毕后，有一个确认按钮，有的场景需要的是回车&…
阅读更多...
GPIO控制和命名规则

GPIO控制和命名规则

Linux提供了GPIO子系统驱动框架，使用该驱动框架即可灵活地控制板子上的GPIO。 GPIO命名 泰山派开发板板载了一个40PIN 2.54间距的贴片排针，排针的引脚定义兼容经典40PIN接口。 在后续对GPIO进行操作前，我们需要先了解k3566的GPIO命名规则&a…
阅读更多...
Unity开发过程中背包系统性能优化方案

Unity开发过程中背包系统性能优化方案

在游戏开发中，背包系统是非常常见并且重要的一部分。然而，如果不合理地设计与实现，它可能导致游戏运行效率降低，影响玩家的游戏体验。在Unity中，背包系统的优化需要考虑以下几个方面： 1. 使用对象池&#x…
阅读更多...
windows10重装系统后, 磁盘目录上出现了一个黄色三角感叹号和一把锁（BitLocker解锁）

windows10重装系统后, 磁盘目录上出现了一个黄色三角感叹号和一把锁（BitLocker解锁）

BitLocker解锁 通过cmd命令窗口关闭Bitlocker锁 通过cmd命令窗口关闭Bitlocker锁 manage-bde -off D:执行这个命令之后会发现提示【解密正在进行中】，但是一般来说对于这种所谓的进行中都会想要明确的看到进度显示 那么就需要用到下一个命令了 manage-bde -status…
阅读更多...
vue transition结合animate.css动画库

vue transition结合animate.css动画库

transition结合animate.css动画库 安装 npm install animate.css --save 在main.js中引用 import animated from animate.css Vue.use(animated) 在transition标签上使用 <transition enter-active-class"animate__animated animate__fadeInUp" leave-acti…
阅读更多...
最新文章

Copyright @ 2022~2023