go-micro V2 从零开始（二）手写第一个微服务

本文相关代码：gitee

---

前言

上一章我们借助micro工具包创建了一个demo程序hello-service，并通过编写hello-cli.go成功实现了微服务调用。

接下来的若干章我们参考示例代码，编写一组自己的微服务，并逐步引入第三方插件，最终编写一个微服务版的todolist程序.

这一章，我们先来手写第一个微服务：task-srv。

作为一个todolist服务，最基础的功能当然是对任务的增删改查等管理操作，考虑到实际业务复杂度，这里我们选择引入mongodb作为系统数据库保存task信息

---

具体步骤

一、创建目录

首先创建项目总的目录，这里我们起名为go-todolist

mkdir go-todolist && cd go-todolist
# 初始化go-todolist为go mod项目
go mod init go-todolist

# 继续创建`task-srv`目录
mkdir task-srv && cd task-srv

# 这部分可以参考上一章的官方demo程序
# 注意这里多出一个repository文件夹用于数据库相关操作
mkdir proto repository handler 
cd proto
mkdir task

此服务只提供gRpc一种调用方式，不订阅消息，因此会发现我们并没有创建subscriber文件夹。

---

二、编写task.proto

新建并编辑task-srv/proto/task/task.proto，这里我们首先定义了task对象的增、删、改和分页查询接口。

需要注意的是，消息体定义使用了限定修饰符，限定修饰符包含required\optional\repeated

• Required: 表示是一个必须字段，必须相对于发送方，在发送消息之前必须设置该字 段的值，对于接收方，必须能够识别该字段的意思。
  这个修饰符在proto3中已废弃
• Optional: 表示是一个可选字段，可选对于发送方，在发送消息时，可以有选择性的设置或者不设置该字段的值。
  对于接收方，如果能够识别可选字段就进行相应的处理，如果无法识别，则忽略该字段，消息中的其它字段正常处理。
  这个修饰符在proto3中是所有字段的默认修饰符
• Repeated: 表示该字段可以包含0~N个元素。其特性和optional一样，但是每一次可以包含多个值。可以看作是在传递一个数组的值。

//声明proto本版
syntax = "proto3";
//服务名
package go.micro.service.task;
//生成go文件的包路径
option go_package = "proto/task";

//定义task服务的接口，主要是增删改查
//结构非常类似于go语言的interface定义，只是返回值必须用括号包裹，且不能使用基本类型作为参数或返回值
service TaskService {
  rpc Create(Task)returns (EditResponse){}
  rpc Delete(Task)returns (EditResponse){}
  rpc Modify(Task)returns (EditResponse){}
  rpc Finished(Task)returns (EditResponse){}
  rpc Search(SearchRequest)returns (SearchResponse){}
}

//下面是消息体message的定义，可以暂时理解为go中的struct，其中的1，2，3...是每个变量唯一的编码
message Task {
  //每条任务的ID，本项目中对应mongodb记录的"_id"字段
  //@inject_tag: bson:"_id"
  string id = 1;
  //任务主体文字
  //@inject_tag: bson:"body"
  string body = 2;
  //用户设定的任务开始时间戳
  //@inject_tag: bson:"startTime"
  int64 startTime = 3;
  //用户设定的任务截止时间戳
  //@inject_tag: bson:"endTime"
  int64 endTime = 4;
  //任务是否已完成
  //@inject_tag: bson:"isFinished"
  int32 isFinished = 5;
  //用户实际完成时间戳
  //@inject_tag: bson:"finishTime"
  int64 finishTime = 6;
  //任务创建时间
  //@inject_tag: bson:"createTime"
  int64 createTime = 7;
  //任务修改时间
  //@inject_tag: bson:"updateTime"
  int64 updateTime = 8;
}

//增删改接口返回参数
message EditResponse {
  //操作返回的消息
  string msg = 1;
}
//查询接口的参数
message SearchRequest{
  //分页查询页码，从第一页开始
  int64 pageSize = 1;
  //分页查询每页数量，默认20
  int64 pageCode = 2;
  // 排序字段
  string sortBy = 3;
  // 顺序 -1降序 1升序
  int32 order=4;
  //关键字模糊查询任务body字段
  string keyword = 5;
}

message SearchResponse{
  //分页查询页码，从第一页开始
  int64 pageSize = 1;
  //分页查询每页数量，默认20
  int64 pageCode = 2;
  // 排序字段
  string sortBy = 3;
  // 顺序 -1降序 1升序
  int32 order=4;
  //数据总数
  int64 total = 5;
  //具体数据，这里repeated表示可以出现多条，类似于go中的slice
  repeated Task rows = 6;
}

细心的朋友会发现，在proto文件中，除了必要的注释外还有一些类似java注解的注释@inject_tag，这是由于protobuf官方的插件不能很好的处理go struct的tag内容，而我们的数据库mongodb又需要在tag中配置bson信息，否则生成的struct无法正确接收_id，另外生成的表字段也会被全部小写不符合阅读习惯。
这里需要引入一个第三方的自动生成工具：

go get -u github.com/favadi/protoc-go-inject-tag

他的配置很简单，只需要在需要设置tag的字段上写类似//@inject_tag bson:"_id"这样的注解即可。
当然，要使用这个工具，也需要调用额外的命令，其中input参数的值是生成后go文件的相对路径。

protoc-go-inject-tag -input=proto/task/task.pb.go

为了便于使用，这里我们参考上一章demo中的makefile文件，在task目录下也创建可以makefile文件：

GOPATH:=$(shell go env GOPATH)
MODIFY=Mproto/imports/api.proto=github.com/micro/go-micro/v2/api/proto

.PHONY: proto
proto:

	protoc --proto_path=. --micro_out=${MODIFY}:. --go_out=${MODIFY}:. proto/task/task.proto
	# 注意这里我们添加了tag控件的命令
	protoc-go-inject-tag -input=proto/task/task.pb.go

.PHONY: build
build: proto

	go build -o task-srv main.go

.PHONY: test
test:
	go test -v ./... -cover

.PHONY: docker
docker:
	docker build . -t task-srv:latest

接下来，在task-srv文件夹下运行make proto即可以生成proto的go文件。

没有make命令的win用户也可以在task-srv目录下直接执行命令：

> protoc --proto_path=. --micro_out=. --go_out=. proto/task/task.proto
> protoc-go-inject-tag -input=proto/task/task.pb.go

这个时候你的两个go文件一定是满屏飘红的，因为缺少依赖，进入task-srv目录，执行go mod tidy下载基础依赖，因为之前demo项目已经下载过相关依赖，这个命令执行会很快。

---

三、实现服务

用编辑器打开task.pb.micro.go，我们首先能看到，protoc已经帮我生成了go语言版的TaskService服务相关代码，根据注释，我们需要实现接口TaskServiceHandler:

...

// Server API for TaskService service

type TaskService interface {
	Create(ctx context.Context, in *Task, opts ...client.CallOption) (*EditResponse, error)
	Delete(ctx context.Context, in *Task, opts ...client.CallOption) (*EditResponse, error)
	Modify(ctx context.Context, in *Task, opts ...client.CallOption) (*EditResponse, error)
	Finished(ctx context.Context, in *Task, opts ...client.CallOption) (*EditResponse, error)
	Search(ctx context.Context, in *SearchRequest, opts ...client.CallOption) (*SearchResponse, error)
}

...

你会注意到，除了我们自己定义的 *Task参数外，go-micro还自动封装了上下文context.Context，原本我们定义的返回值EditResponse变成了一个指针参数。
接下来我们就要实现这四个接口，我习惯的开发顺序是 数据库操作->业务实现->注册服务。

---

3.1 数据库操作

新建并编辑task-srv/repository/task.go

package repository

import (
	"context"
	"github.com/pkg/errors"
	pb "go-todolist/task-srv/proto/task"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"strings"
	"time"
)

const (
	// 默认数据库名
	DbName = "todolist"
	// 默认表名
	TaskCollection = "task"
	UnFinished     = 0
	Finished       = 1
)

// 定义数据库基本的增删改查操作
type TaskRepository interface {
	InsertOne(ctx context.Context, task *pb.Task) error
	Delete(ctx context.Context, id string) error
	Modify(ctx context.Context, task *pb.Task) error
	Finished(ctx context.Context, task *pb.Task) error
	Count(ctx context.Context, keyword string) (int64, error)
	Search(ctx context.Context, req *pb.SearchRequest) ([]*pb.Task, error)
}

// 数据库操作实现类
type TaskRepositoryImpl struct {
	// 需要注入一个数据库连接客户端
	Conn *mongo.Client
}

// 定义默认的操作表
func (repo *TaskRepositoryImpl) collection() *mongo.Collection {
	return repo.Conn.Database(DbName).Collection(TaskCollection)
}

func (repo *TaskRepositoryImpl) InsertOne(ctx context.Context, task *pb.Task) error {
	_, err := repo.collection().InsertOne(ctx, bson.M{
		"body":       task.Body,
		"startTime":  task.StartTime,
		"endTime":    task.EndTime,
		"isFinished": UnFinished,
		"createTime": time.Now().Unix(),
	})
	return err
}

func (repo *TaskRepositoryImpl) Delete(ctx context.Context, id string) error {
	oid, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return err
	}
	_, err = repo.collection().DeleteOne(ctx, bson.M{"_id": oid})
	return err
}

func (repo *TaskRepositoryImpl) Modify(ctx context.Context, task *pb.Task) error {
	id, err := primitive.ObjectIDFromHex(task.Id)
	if err != nil {
		return err
	}
	_, err = repo.collection().UpdateOne(ctx, bson.M{"_id": id}, bson.M{"$set": bson.M{
		"body":       task.Body,
		"startTime":  task.StartTime,
		"endTime":    task.EndTime,
		"updateTime": time.Now().Unix(),
	}})
	return err
}
func (repo *TaskRepositoryImpl) Finished(ctx context.Context, task *pb.Task) error {
	id, err := primitive.ObjectIDFromHex(task.Id)
	if err != nil {
		return err
	}
	now := time.Now().Unix()
	update := bson.M{
		"isFinished": int32(task.IsFinished),
		"updateTime": now,
	}
	if task.IsFinished == Finished {
		update["finishTime"] = now
	}
	log.Print(task)
	log.Println(update)
	_, err = repo.collection().UpdateOne(ctx, bson.M{"_id": id}, bson.M{"$set": update})
	return err
}

func (repo *TaskRepositoryImpl) Count(ctx context.Context, keyword string) (int64, error) {
	filter := bson.M{}
	if keyword != "" && strings.TrimSpace(keyword) != "" {
		filter = bson.M{"body": bson.M{"$regex": keyword}}
	}
	count, err := repo.collection().CountDocuments(ctx, filter)
	return count, err
}

func (repo *TaskRepositoryImpl) Search(ctx context.Context, req *pb.SearchRequest) ([]*pb.Task, error) {
	filter := bson.M{}
	if req.Keyword != "" && strings.TrimSpace(req.Keyword) != "" {
		filter = bson.M{"body": bson.M{"$regex": req.Keyword}}
	}

	cursor, err := repo.collection().Find(ctx,
		filter,
		options.Find().SetSkip((req.PageCode-1)*req.PageSize),
		options.Find().SetLimit(req.PageSize),
		options.Find().SetSort(bson.M{req.SortBy: req.Order}))
	if err != nil {
		return nil, errors.WithMessage(err, "search mongo")
	}
	var rows []*pb.Task
	if err := cursor.All(ctx, &rows); err != nil {
		return nil, errors.WithMessage(err, "parse data")
	}
	return rows, nil
}

---

3.2 业务实现

新建并编辑task-srv/handler\task.go这里注意，真正的返回值是通过操作resp参数返回的:

package handler

import (
	"context"
	"github.com/pkg/errors"
	pb "go-todolist/task-srv/proto/task"
	"go-todolist/task-srv/repository"
)

// 要实现接口，首先当然要定义一个结构体
type TaskHandler struct {
	TaskRepository repository.TaskRepository
}

func (t *TaskHandler) Create(ctx context.Context, req *pb.Task, resp *pb.EditResponse) error {
	if req.Body == "" || req.StartTime <= 0 || req.EndTime <= 0 {
		return errors.New("bad param")
	}
	if err := t.TaskRepository.InsertOne(ctx, req); err != nil {
		return err
	}
	resp.Msg = "success"
	return nil
}
func (t *TaskHandler) Delete(ctx context.Context, req *pb.Task, resp *pb.EditResponse) error {
	if req.Id == "" {
		return errors.New("bad param")
	}
	if err := t.TaskRepository.Delete(ctx, req.Id); err != nil {
		return err
	}
	resp.Msg = req.Id
	return nil
}
func (t *TaskHandler) Modify(ctx context.Context, req *pb.Task, resp *pb.EditResponse) error {
	if req.Id == "" || req.Body == "" || req.StartTime <= 0 || req.EndTime <= 0 {
		return errors.New("bad param")
	}
	if err := t.TaskRepository.Modify(ctx, req); err != nil {
		return err
	}
	resp.Msg = "success"
	return nil
}
func (t *TaskHandler) Finished(ctx context.Context, req *pb.Task, resp *pb.EditResponse) error {
	if req.Id == "" || req.IsFinished != repository.UnFinished && req.IsFinished != repository.Finished {
		return errors.New("bad param")
	}
	if err := t.TaskRepository.Finished(ctx, req); err != nil {
		return err
	}
	resp.Msg = "success"
	return nil
}
func (t *TaskHandler) Search(ctx context.Context, req *pb.SearchRequest, resp *pb.SearchResponse) error {
	count, err := t.TaskRepository.Count(ctx, req.Keyword)
	if err != nil {
		return errors.WithMessage(err, "count row number")
	}
	if req.PageCode <= 0 {
		req.PageCode = 1
	}
	if req.PageSize <= 0 {
		req.PageSize = 20
	}
	if req.SortBy == "" {
		req.SortBy = "createTime"
	}
	if req.Order == 0 {
		req.Order = -1
	}
	if req.PageSize*(req.PageCode-1) > count {
		return errors.New("There's not that much data")
	}
	rows, err := t.TaskRepository.Search(ctx, req)
	if err != nil {
		return errors.WithMessage(err, "search data")
	}
	*resp = pb.SearchResponse{
		PageCode: req.PageCode,
		PageSize: req.PageSize,
		SortBy:   req.SortBy,
		Order:    req.Order,
		Rows:     rows,
	}
	return nil
}

---

3.3 注册服务

最后的最后，我们参考上一章的main.go，注册我们的服务。
这里需要说明的是，在v2版本中go-micro默认使用mdns作为服务发现，他无需安装部署主要用于学习和简单场景开发，生产环境官方建议使用etcd，这个我们在后面的插件部分再套路。
另外，由于本服务暂时没有需要处理的消息，我们删除了消息相关接口。
最后，我们配置了mongo连接作为数据库（关于mongo的搭建请自行搜索）：

package main

import (
	"context"
	"github.com/micro/go-micro/v2"
	"github.com/pkg/errors"
	"go-todolist/task-srv/handler"
	pb "go-todolist/task-srv/proto/task"
	"go-todolist/task-srv/repository"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

// 这里是我内网的mongo地址，请根据你得实际情况配置，推荐使用dockers部署
const MONGO_URI = "mongodb://172.18.0.58:27017"

func main() {
	// 在日志中打印文件路径，便于调试代码
	log.SetFlags(log.Llongfile)

	conn, err := connectMongo(MONGO_URI, time.Second)
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Disconnect(context.Background())

	// New Service
	service := micro.NewService(
		micro.Name("go.micro.service.task"),
		micro.Version("latest"),
	)

	// Initialise service
	service.Init()

	// Register Handler
	taskHandler := &handler.TaskHandler{
		TaskRepository: &repository.TaskRepositoryImpl{
			Conn: conn,
		},
	}
	if err := pb.RegisterTaskServiceHandler(service.Server(), taskHandler); err != nil {
		log.Fatal(errors.WithMessage(err, "register server"))
	}

	// Run service
	if err := service.Run(); err != nil {
		log.Fatal(errors.WithMessage(err, "run server"))
	}
}

// 连接到MongoDB
func connectMongo(uri string, timeout time.Duration) (*mongo.Client, error) {
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()
	client, err := mongo.Connect(ctx, options.Client().ApplyURI(uri))
	if err != nil {
		return nil, errors.WithMessage(err, "create mongo connection session")
	}
	return client, nil
}

---

四、运行并校验

4.1 运行

运行make build或者go build -o task-srv main.go打包程序，这个时候你大概率会看到如下错误：

这是因为etcd包的一个版本兼容性问题，为什么之前的hello服务没有遇到这个情况呢，查看micro工具自动生成的go.mod文件，会发现如下内容：

// This can be removed once etcd becomes go gettable, version 3.4 and 3.5 is not,
// see https://github.com/etcd-io/etcd/issues/11154 and https://github.com/etcd-io/etcd/issues/11931.
replace google.golang.org/grpc => google.golang.org/grpc v1.26.0

根据提示在我们的task-srv/go.mod中加入

replace google.golang.org/grpc => google.golang.org/grpc v1.26.0

再次运行：

> go run main.go
2020-09-10 17:42:46  file=v2@v2.9.1/service.go:200 level=info Starting [service] go.micro.service.task
2020-09-10 17:42:46  file=grpc/grpc.go:864 level=info Server [grpc] Listening on [::]:63776
2020-09-10 17:42:46  file=grpc/grpc.go:697 level=info Registry [mdns] Registering node: go.micro.service.task-816e865d-7d43-4d02-94b4-be11cd475193

终于成功运行。

---

4.2 task-cli 调用服务

与上一章类似，新建并编辑task-srv/task-cli.go:

package main

import (
	"context"
	"github.com/micro/go-micro/v2"
	"log"
	pb "task-srv/proto/task"
	"task-srv/repository"
	"time"
)

func main() {
	// 在日志中打印文件路径，便于调试代码
	log.SetFlags(log.Llongfile)
	// 客户端也注册为服务
	server := micro.NewService(micro.Name("go.micro.client.task"))
	server.Init()
	taskService := pb.NewTaskService("go.micro.service.task", server.Client())

	// 调用服务生成三条任务
	now := time.Now()
	insertTask(taskService, "完成学习笔记（一）", now.Unix(), now.Add(time.Hour*24).Unix())
	insertTask(taskService, "完成学习笔记（二）", now.Add(time.Hour*24).Unix(), now.Add(time.Hour*48).Unix())
	insertTask(taskService, "完成学习笔记（三）", now.Add(time.Hour*48).Unix(), now.Add(time.Hour*72).Unix())

	// 分页查询任务列表
	page, err := taskService.Search(context.Background(), &pb.SearchRequest{
		PageCode: 1,
		PageSize: 20,
	})
	if err != nil {
		log.Fatal("search1", err)
	}
	log.Println(page)

	// 更新第一条记录为完成
	row := page.Rows[0]
	if _, err = taskService.Finished(context.Background(), &pb.Task{
		Id:         row.Id,
		IsFinished: repository.Finished,
	}); err != nil {
		log.Fatal("finished", row.Id, err)
	}

	// 修改查询到的第二条数据,延长截至日期
	row = page.Rows[1]
	if _, err = taskService.Modify(context.Background(), &pb.Task{
		Id:        row.Id,
		Body:      row.Body,
		StartTime: row.StartTime,
		EndTime:   now.Add(time.Hour * 72).Unix(),
	}); err != nil {
		log.Fatal("modify", row.Id, err)
	}

	// 删除第三条记录
	row = page.Rows[2]
	if _, err = taskService.Delete(context.Background(), &pb.Task{
		Id: row.Id,
	}); err != nil {
		log.Fatal("delete", row.Id, err)
	}

	// 再次分页查询，校验修改结果
	page, err = taskService.Search(context.Background(), &pb.SearchRequest{})
	if err != nil {
		log.Fatal("search2", err)
	}
	log.Println(page)
}
func insertTask(taskService pb.TaskService, body string, start, end int64) {
	_, err := taskService.Create(context.Background(), &pb.Task{
		Body:      body,
		StartTime: start,
		EndTime:   end,
	})
	if err != nil {
		log.Fatal("create", err)
	}
	log.Println("create task success! ")
}

运行后就可以看到如下结果：

>go run task-cli.go
2020-09-11 02:46:17.731409 I | E:/go-workspace/go-micro-study-notes/go-todolist1/task-srv/task-cli.go:79: create task success!
2020-09-11 02:46:17.732439 I | E:/go-workspace/go-micro-study-notes/go-todolist1/task-srv/task-cli.go:79: create task success!
2020-09-11 02:46:17.733434 I | E:/go-workspace/go-micro-study-notes/go-todolist1/task-srv/task-cli.go:79: create task success!
2020-09-11 02:46:17.734431 I | E:/go-workspace/go-micro-study-notes/go-todolist1/task-srv/task-cli.go:33: pageSize:20  pageCode:1  sortBy:"CreateTime"  order:-1  rows:{id:"5f5a74791f01617808fef8b6"  body:"完成学习笔记（一）
"  startTime:1599763577  endTime:1599849977  createTime:1599763577}  rows:{id:"5f5a74791f01617808fef8b7"  body:"完成学习笔记（二）"  startTime:1599849977  endTime:1599936377  createTime:1599763577}  rows:{id:"5f5a74791f0161
7808fef8b8"  body:"完成学习笔记（三）"  startTime:1599936377  endTime:1600022777  createTime:1599763577}
2020-09-11 02:46:17.738421 I | E:/go-workspace/go-micro-study-notes/go-todolist1/task-srv/task-cli.go:68: pageSize:20  pageCode:1  sortBy:"CreateTime"  order:-1  rows:{id:"5f5a74791f01617808fef8b6"  body:"完成学习笔记（一）
"  startTime:1599763577  endTime:1599849977  isFinished:1  finishTime:1599763577  createTime:1599763577  updateTime:1599763577}  rows:{id:"5f5a74791f01617808fef8b7"  body:"完成学习笔记（二）"  startTime:1599849977  endTime:
1600022777  createTime:1599763577  updateTime:1599763577}

---

总结

本章我们参照demo示例，从头开始手写了一个完整的微服务task-srv，并且引入了数据库操作。
下一章我们将围绕这个核心服务再开发两个新的微服务，并尝引入之前被我们搁置的消息服务。

---

支持一下

原创不易，支持一下买杯咖啡，谢谢:p