笔记大全

怎么使用 Go 语言进行分布式开发

更新时间：2023-11-10

Go 语言分布式开发概述

分布式开发是现代互联网时代的一项非常重要的技术，对于提高系统性能和应用的高可用性都有非常明显的促进作用。Go 语言具有并发编程的优势，也能够很好地支持分布式开发，在一些大并发并分布式应用中被广泛使用。

使用 Go 语言的 RPC 实现分布式开发

远程过程调用（RPC）是 Go 语言中实现分布式系统通讯最为常用的方式之一，它可以让客户端程序像调用本地程序一样调用远程程序。实现 RPC 通讯的方式一般有两种，一种是基于 HTTP 协议的 JSON -RPC，另一种是基于 TCP 和 Protobuf 实现的高性能 RPC。

	//基于 JSON 的 RPC 实现
	rpc.Register(new(HelloService))  //注册 rpc 服务
	rpc.HandleHTTP() // 注册 HTTP 服务
	l, e := net.Listen("tcp", ":1234")
	if e != nil {
		log.Fatal("listen error:", e)
	}
	http.Serve(l, nil)
	
	func ClientInvoke() {
		client, err := rpc.DialHTTP("tcp", "localhost:1234") //建立命名客户端
		if err != nil {
			log.Fatal("dialing:", err)
		}
		var reply string  //声明返回值
		err = client.Call("HelloService.Hello", "mh552p", &reply)  //调用 RPC 需要传入方法名以及参数
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(reply)
	}

	//基于 ProtoBuf 和 TCP 的 RPC 实现
	//编写 proto 文件
	syntax = "proto3";
	message HelloRequest {
	    string name = 1;
	}
	message HelloReply {
	    string message = 1;
	}
	service HelloService {
	    rpc Hello (HelloRequest) returns (HelloReply);
	}
	//生成 stub 代码
	protoc --go_out=. hello.proto

	//服务端代码
	grpcServer := grpc.NewServer()
	RegisterHelloServiceServer(grpcServer, &server{})
	lis, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	err = grpcServer.Serve(lis)
	if err != nil {
		log.Fatalf("failed to serve: %v", err)
	}

	//客户端代码
	conn, err := grpc.Dial(":8080", grpc.WithInsecure())
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := NewHelloServiceClient(conn)
	resp, err := client.Hello(context.Background(), &HelloRequest{Name: "mh552p"})
	fmt.Println(resp.Message)

使用 Go 语言实现分布式缓存系统

分布式缓存系统是相对于单机缓存而言的，实现分布式缓存有很多种方式，比如自己实现一套集群化的缓存系统或者使用第三方的分布式内存缓存产品如 Redis 等。Go 语言有很多支持分布式开发的缓存库，如 go-redis、gomemcache 等等，这些缓存库与缓存服务器通讯都是使用像 TCP、HTTP 或者 protobuf 这类协议通讯的，而缓存库本身提供一些 API，方便我们进行缓存的操作。

	//go-redis 缓存库使用示例
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})
	err := client.Set("key", "value", 0).Err()  //写入缓存
	if err != nil {
		panic(err)
	}
	val, err := client.Get("key").Result() // 读取缓存
	if err != nil {
		panic(err)
	}
	fmt.Println("key", val)

使用 Go 语言实现分布式系统中的消息队列

在分布式应用开发过程中，消息队列是非常实用的一种技术，可以让分布式系统之间的数据交互变得更为高效。在 Go 语言中，我们可以使用 RabbitMQ、Kafka 等第三方消息队列中间件，也可以通过自己实现消息队列来满足需求。

	//使用 RabbitMQ 的示例
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	defer conn.Close()
	ch, err := conn.Channel()
	defer ch.Close()
	q, err := ch.QueueDeclare(
		"test_queue",
		false,
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
	}
	body := "test message"
	err = ch.Publish(
		"",
		q.Name,
		false,
		false,
		amqp.Publishing{
			DeliveryMode: amqp.Persistent,
			ContentType:  "text/plain",
			Body:         []byte(body),
		})
	if err != nil {
		fmt.Println(err)
	}
	msgs, err := ch.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
	}
	forever := make(chan bool)
	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
		}
	}()
	<-forever

c语言编程笔录