1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

//服务端，求矩形周长
//声明矩形对象
type Rect struct {
}

//声明从客户接受的参数结构体
type Params struct {
	Width,Height int
}

//声明返回给客户端的参数结构体
type Ret struct {
	Area int
	Perimeter int
}

//定义求矩形面积和周长的方法,第二个参数必须是指针，因为是其他服务调用此服务
//第二个参数也可以定义一个普通类型进行返回
//返回值error如果不为空，那么无论接受参数是否已经有值，服务端都不会返回数据，error和传出参数只会有一个是非空
func (r *Rect)Area(p Params,ret *Ret) error{
	ret.Area=p.Width*p.Height
	ret.Perimeter=(p.Width+p.Height)*2
	return nil
}

func main(){
	//1.注册服务
	rpc.Register(new(Rect))
	//2.把服务绑定到http协议上
	rpc.HandleHTTP()
	//3.监听服务，等待客户端调用方法
	err:=http.ListenAndServe(":8989",nil)
	if err != nil {
		return
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//客户端，请求服务端，获取结果
//声明参数结构体
type Params struct {
	Width,Height int
}

type Ret struct {
	Area int
	Perimeter int
}
func main() {
	//1. 连接远程的RPC服务
	rp, err := rpc.DialHTTP("tcp", "127.0.0.1:8989")
	if err != nil {
		log.Fatal(err)
	}
	//2. 调用远程方法
	var ret Ret
	//第一个参数为方法名，为服务器对应的结构体名.方法名，第二个参数为传过去的参数，第三个参数为接受到的参数，与服务器对应的参数类型要一致
	err = rp.Call("Rect.Area", Params{10, 20}, &ret)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("面积：%v\n周长：%v\n",ret.Area,ret.Perimeter)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

//服务端
//1.注册服务
	rpc.Register(new(Rect))
	//2. 监听端口
	listen, err := net.Listen("tcp", "127.0.0.1:8989")
	if err != nil {
		log.Fatal(err)
	}
	//3. 循环监听服务
	for {
		conn, err := listen.Accept()
		if err != nil {
			log.Fatal(err)
			continue
		}
		go func(conn net.Conn) {
			//客户端只需要把rpc.DialHTTP变成jsonrpc.Dial即可
			fmt.Println("create new a Client")
			jsonrpc.ServeConn(conn)
		}(conn)
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

go get -u -v github.com/golang/protobuf/proto

go get google.golang.org/grpc（如果无法使用， 用如下命令代替）
		git clone https://github.com/grpc/grpc-go.git$GOPATH/src/google.golang.org/grpc
		git clone https://github.com/golang/net.git$GOPATH/src/google.golang.org/grpc
		git clone https://github.com/golang/net.git$GOPATH/src/golang.org/x/net
		git clone https://github.com/golang/text.git$GOPATH/src/golang.org/x/text
		go get -u github.com/golang/protobuf/{proto,protoc-gen-go}
		git clone https://github.com/google/go-genproto.git GOPATH/src/golang.org/x/text
		go get −u github.com/golang/protobuf/proto,protoc−gen−go
	git clone https://github.com/google/go−genproto.gitGOPATH/src/google.golang.org/genproto
		cd $GOPATH/src/
		go install google.golang.org/grpc

go get github.com/golang/protobuf/protoc-gen-go

上面安装好后， 会在 GOPATH/bin 下生成 protoc-gen-go.exe
但还需要一个 protoc.exe， windows 平台编译受限， 很难自己手动编译， 直接去网
站下载一个， 地址： https://github.com/protocolbuffers/protobuf/releases/tag/v3.9.0 ，
同样放到 GOPATH/bin 下

1
2
3

message SongServerRequest {
    required string song_name = 1;
}

1
2
3
4

enum Foo {
FIRST_VALUE = 0;	// 枚举值必须从0开始
SECOND_VALUE = 1;
}

1
2
3
4
5
6

syntax ="proto3";
message SearchRequest {
	string query = 1;            // 查询字符串
	int32 page_number = 2;     // 页码
	int32 result_per_page = 3;   // 每页条数
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

message SearchResponse {
	repeated Result results = 1;
}
message Result {
	string url = 1;
	string title = 2;
	repeated string snippets = 3;
}

//内部声明的message类型名称只可在内部直接使用
message SearchResponse {
    message Result {
        string url = 1;
        string title = 2;
        repeated string snippets = 3;
    }
    repeated Result results = 1;
}

1
2
3

//map<key_type, value_type> map_field = N;
message Project {...}
map<string, Project> projects = 1;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

syntax = "proto3";
package proto;
// 编译到当前目录下的proto目录下，包名也会叫proto
option go_package="./proto";

message UserRequest{
    string name = 1;
}

message UserResponse{
    int32 id = 1;
    string name = 2;
    int32 age = 3;
    repeated string hobby = 4;
}

service UserInfoService{
    rpc GetUserInfo(UserRequest) returns (UserResponse){}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	pb "main/gRPC/proto"
	"net"
)
//定义一个结构体用于实现protobuf生成出来的接口的方法,这样子就可以将这个结构体通过传参的方式进行注册
type UserInfoService struct {}
//实现接口中的函数
func (u *UserInfoService)GetUserInfo(ctx context.Context, req *pb.UserRequest) (resp *pb.UserResponse,err error){
	name:=req.Name
	if name=="zs"{
		resp=&pb.UserResponse{
			Id: 1,
			Name: name,
			Age: 22,
			Hobby: []string{"run","game"},
		}
	}
	return
}

var UserInfo = UserInfoService{}

func main(){
	addr:="127.0.0.1:8999"
	// 1.监听端口
	listen, err := net.Listen("tcp", addr)
	if err != nil {
		fmt.Println("监听失败,",err)
		return
	}
	defer listen.Close()
	// 2.实例化gRPC
	s := grpc.NewServer()
	// 3.在gRPC上注册微服务
	pb.RegisterUserInfoServiceServer(s,&UserInfo)
	// 4.启动服务端
	s.Serve(listen)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	pb "main/gRPC/proto"
)

func main(){
	// 1.连接,必须设置传输安全WithInsecure(),作用是关闭传输安全。不加则会报错
	conn, err := grpc.Dial("127.0.0.1:8999",grpc.WithInsecure())
	if err != nil {
		fmt.Println("连接异常,",err)
		return
	}
	defer conn.Close()
	// 2.实例化客户端
	client := pb.NewUserInfoServiceClient(conn)
	// 3.组装一个请求参数
	req:=new(pb.UserRequest)
	req.Name="zs"
	// 4.调用接口
	resp, err := client.GetUserInfo(context.Background(), req)
	if err != nil {
		fmt.Println("响应异常，",err)
	}
	fmt.Printf("响应结果%v\n",resp)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package main

import (
	"context"
	"fmt"
	"github.com/micro/go-micro"
	"log"
	pb "mico/proto"
)

type Hello struct {}

func (h *Hello)Info(ctx context.Context,req *pb.UserRequest,resp *pb.UserResponse) error{
	resp.Msg="hello"+req.Name
	return nil
}

func main() {
	// 1.得到服务端实例，Name()用于设置微服务的名，用来访问
	//cmd命令： micro call hello Hello.Info {"username":"zs"}
	service := micro.NewService(micro.Name("hello"))
	// 2.初始化
	service.Init()
	// 3.服务注册
	err := pb.RegisterUserInfoServiceHandler(service.Server(), new(Hello))
	if err != nil {
		fmt.Println(err)
	}
	// 4.启动服务
	err = service.Run()
	if err != nil {
		log.Fatal(err)
	}
}


syntax = "proto3";
package proto;

message UserRequest{
    string name = 1;
}
message UserResponse{
    string msg = 1;
}
service UserInfoService{
    rpc Info(UserRequest) returns (UserResponse){}
}

protoc -I . --micro_out=. --go_out=. ./user.proto

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// "github.com/hashicorp/consul/api"
	//把grpc注册到consul上
	// 1.初始化consul配置
	consulConfig := api.DefaultConfig()
	// 2.创建consul对象,此时server对于consul是客户端，因此是NewClient
	consulClient, err := api.NewClient(consulConfig)
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	// 3. 通知consul即将注册的服务的配置信息
	reg := api.AgentServiceRegistration{
		ID:   "1",
		Tags: []string{"server tag"},
		Name: "server",
		// 此处的ip port和check的ip port要与grpc监听的ip port一致
		// 这里的ip端口是监听的目标端口，并不是consul自己的端口
		Port:    8999,
		Address: "127.0.0.1",
		Check: &api.AgentServiceCheck{
			TCP:      "127.0.0.1:8999",
			Timeout:  "1s",
			Interval: "5s",
		},
	}
	// 4. 注册grpc服务到consul上
	err = consulClient.Agent().ServiceRegister(&reg)
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	fmt.Println("注册成功")

	//############以下为grpc远程调用####################
	addr := "127.0.0.1:8999"
	// 1.监听端口
	listen, err := net.Listen("tcp", addr)
	if err != nil {
		fmt.Println("监听失败,", err)
		return
	}
	defer listen.Close()
	// 2.实例化gRPC
	s := grpc.NewServer()
	// 3.在gRPC上注册微服务
	teacher.RegisterSayServer(s, &SayStruct{})
	// 4.启动服务端
	s.Serve(listen)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

	// "github.com/hashicorp/consul/api"
	// 1.初始化consul配置
	consulConfig := api.DefaultConfig()
	// 2.创建consul对象,此时server对于consul是客户端，因此是NewClient
	consulClient, err := api.NewClient(consulConfig)
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	// 参数： service：对应服务名; tag:别名，如有多个就任选一个；passingOnly; 是否通过健康检查，通常要找通过的，即true; QueryOptions：查询参数，通常传nil
	// 返回值：ServiceEntry:存储服务的切片，因为一个服务可以分成主从的同名多个服务, QueryMeta：查询参数的返回值，传nil返nil
	service, _, err := consulClient.Health().Service("server", "server tag", true, nil)
	if err != nil || len(service) == 0 {
		return
	}
	addr := fmt.Sprintf("%v:%v", service[0].Service.Address, service[0].Service.Port)
	//############以下为grpc远程调用####################
	// 1.连接,必须设置传输安全WithInsecure()，否则会报错
	conn, err := grpc.Dial(addr, grpc.WithInsecure())
	if err != nil {
		fmt.Println("连接异常,", err)
		return
	}
	defer conn.Close()
	// 2.实例化客户端
	client := teacher.NewSayClient(conn)
	// 3.组装一个请求参数
	req := new(teacher.Teacher)
	// 4.调用接口
	resp, err := client.SayHellp(context.Background(), req)
	if err != nil {
		fmt.Println("响应异常，", err)
	}

1
2
3
4

#指定服务的命名空间
--namespace "go.micro"	Namespace for the service e.g com.example
#服务类型，可以是微服务srv,或者web项目,或者api等
--type "srv"			Type of service e.g api, fnc, srv, web

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

	// 初始化服务发现--consul: "github.com/asim/go-micro/plugins/registry/consul/v4"
	// registry: "go-micro.dev/v4/registry"
	consulReg := consul.NewRegistry(
		// 这个可以指定对应的consul地址,不加的话默认是连接本机的8500端口的consul
		func(o *registry.Options) {
			o.Addrs = []string{
				// 配置consul服务地址
				"127.0.0.1:8500",
			}
		})
	// Create service   初始化服务器对象
	srv := micro.NewService(
		micro.Address("127.0.0.1:8999"), // 指定ip和端口，如果不指定的话，micro会随机分配一个端口
		micro.Name("test-micro"), // 服务器名
		micro.Version("latest"),  // 版本，latest为最终版本，最新
		micro.Registry(consulReg), // 注册到consul上
		// 设置命令行参数  --run_client,BoolFlag默认值是false。与init配套。如果不需要命令行可以不加
		micro.Flags(&cli.BoolFlag{
			Name:  "run_client",
			Usage: "Launch the client",
		}),
	)

	// init作用于对newService中的flags进行加工处理，如果没有flag可以不调用
	// 建议不调用，因为init如果加了和newService中相同的参数，如micro.Name("newName")，它会覆盖掉之前的。导致name变成newName
	// 后续代码运行期想重新初始化才有必要调用此函数
	// srv.Init(micro.Action(func(c *cli.Context) error {
	// 	if c.Bool("run_client") {
	// 		fmt.Println("run_client cmd")
	// 		os.Exit(0)
	// 	}
	// 	return nil
	// }))
	// Register handler   注册服务
	pb.RegisterTestMicroHandler(srv.Server(), new(handler.TestMicro))

	// Run service  运行服务
	if err := srv.Run(); err != nil {
		return
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

func main() {
	route := gin.Default()
	route.GET("/", handlerFuncsTest)
	route.Run(":8080")
}

func handlerFuncsTest(c *gin.Context) {
// 初始化服务发现consul，可以加参数指定consul的地址，不加默认为本机的8500端口
	consulReg := consul.NewRegistry(
		func(o *registry.Options) {
			o.Addrs = []string{
				// 配置consul服务地址
				"127.0.0.1:8500",
			}
		},
	)

	// 初始化micro对象，指定consul为服务发现
	service := micro.NewService(
		micro.Registry(consulReg),
	)
	// 初始化客户端，client.DefaultClient是go-micro.dev/v4/client包的
	// 如果使用默认的mdns，则是client.DefaultClient
	// microClient := pb.NewTestMicroService("test-micro", client.DefaultClient) 
	microClient := pb.NewTestMicroService("test-micro", service.Client())
	// 可以将服务端的pb复制过来，也可以通过mod直接调用服务端的pb,在服务端中，handler后缀的是给服务端使用的注册，service是给客户端使用的调用
	resp, _ := microClient.Call(context.TODO(), &pb.Request{Name: "zs"})
	c.JSON(http.StatusOK, gin.H{
		"resp": resp,
	})
}