Go语言——kratos微服务框架使用

一、安装依赖

• 1、设置代理
  
• 2、安装依赖

# 安装Kratos tool
go install github.com/go-kratos/kratos/cmd/kratos/v2@latest

二、创建项目

# 然后在GOPATH\bin目录下能找到kratos.exe，在需要创建项目的目录下执行，即可创建项目
kratos new helloworld
# 如果默认的github不通的话，可以用gitee拉取
kratos new helloworld -r https://gitee.com/go-kratos/kratos-layout.git

三、初始化项目

# 进入helloworld目录
cd helloworld
# 初始化项目
make init

• 如果没有make命令，可以在网盘中下载
• 如果没有protoc命令，也可以在网盘中下载，并配置其环境变量

四、使用git_bash命令终端运行命令

# 初始化
make init
# 生成api
make api
# 构建
make build
# 所有操作
make all
# 启动kracos
kracos run
# 测试
curl 'http://127.0.0.1:8000/kracos'

五、创建自己的项目

# 创建内容管理项目
kratos new ContentManage -r https://gitee.com/go-kratos/kratos-layout.git

# 进入目录
cd ./ContentManage

# 拉取依赖
go mod download

# 1.添加我们的自定义协议，并修改为我们自定义的接口，如下
kratos proto add api/operate/app.proto

# 2.修改完成之后，重新生成go文件
make api

# 3.在internal/service下创建app.go文件。代码如下
# 4.修改internal/service/service.go文件
# 5.创建internal/biz/content.go文件
# 6.修改internal/biz/biz.go文件
# 7.创建internal/data/content.go文件
# 8.修改internal/data/data.go文件
# 9.修改ContentManage/configs/config.yaml文件
# 10.执行命令，重新生成代码
make all
# 11.启动
kratos run
# 12.创建ContentManage/cmd/client/client.go，来rpc调用方法

1、修改app.proto

syntax = "proto3";

import "google/api/annotations.proto";

package api.operate;

option go_package = "ContentManage/api/operate;operate";
option java_multiple_files = true;
option java_package = "api.operate";

service App {
	// 创建内容
	rpc CreateContent (CreateContentReq) returns (CreateContentResp) {
		option (google.api.http) = {
			post: "/api/cms/content/create",
			body: "content"
		};
	};
}

message Content {
	// 内容id
	int64 id = 1;
	// 内容标题
	string title = 2;
	// 视频播放url
	string videoUrl = 3;
	// 作者
	string author = 4;
	// 内容描述
	string description =5;
	// 封面图url
	string thumbnail = 6;
	// 内容分类
	string category = 7;
	// 内容时长
	int64 duration = 8;
	// 分辨率
	string resolution = 9;
	// 文件大小
	int64 fileSize = 10;
	// 文件格式
	string format = 11;
	// 视频质量1-高清 2-标清
	int32 quality = 12;
	// 审核状态 1-审核中 2-审核通过 3-审核不通过
	int32 approvalStatus = 13;
}

message CreateContentReq {
	// 内容
	Content content = 1;
}
message CreateContentResp {

}

3、internal/service/app.go

package service

import (
	"ContentManage/api/operate"
	"ContentManage/internal/biz"
)

type AppService struct {
	operate.UnimplementedAppServer
	uc *biz.ContentUsecase
}

// NewAppService new a app service.
func NewAppService(uc *biz.ContentUsecase) *AppService {
	return &AppService{uc: uc}
}

4、修改internal/service/service.go文件

package service

import "github.com/google/wire"

// ProviderSet is service providers.
var ProviderSet = wire.NewSet(NewAppService)

5、创建internal/biz/content.go文件

package biz

import (
	"context"
	"github.com/go-kratos/kratos/v2/log"
	"time"
)

type Content struct {
	Id             int           `gorm:"column:id;primary_key"`  // 内容id
	Title          string        `gorm:"column:title"`           // 内容标题
	Description    string        `gorm:"column:description"`     // 内容描述
	Author         string        `gorm:"column:author"`          // 作者
	VideoUrl       string        `gorm:"column:video_url"`       // 视频播放URL
	Thumbnail      string        `gorm:"column:thumbnail"`       // 封面页URL
	Category       string        `gorm:"column:category"`        // 内容分类
	Duration       time.Duration `gorm:"column:duration"`        // 内容时长
	Resolution     string        `gorm:"column:resolution"`      // 分辨率
	FileSize       int64         `gorm:"column:file_size"`       // 文件大小
	Format         string        `gorm:"column:format"`          // 文件格式 如MP4等
	Quality        int32         `gorm:"column:quality"`         // 视频质量 1-高清 2-标清
	ApprovalStatus int32         `gorm:"column:approval_status"` // 审核状态 1-审核中 2-审核通过 3-审核不通过
	CreatedAt      time.Time     `gorm:"column:created_at"`      // 内容创建时间
	UpdatedAt      time.Time     `gorm:"column:updated_at"`      // 内容更新时间
}

func (c Content) TableName() string {
	return "cms_content.t_content_detail"
}

type ContentRepo interface {
	Create(context.Context, *Content) error
}

type ContentUsecase struct {
	repo ContentRepo
	log  *log.Helper
}

// NewContentUsecase new a Content usecase.
func NewContentUsecase(repo ContentRepo, logger log.Logger) *ContentUsecase {
	return &ContentUsecase{repo: repo, log: log.NewHelper(logger)}
}

func (uc *ContentUsecase) CreateContext(ctx context.Context, content *Content) error {
	uc.log.WithContext(ctx).Infof("CreateContext: %v+v", content)
	return uc.repo.Create(ctx, content)
}

6、修改internal/biz/biz.go文件

package biz

import "github.com/google/wire"

// ProviderSet is biz providers.
var ProviderSet = wire.NewSet(NewContentUsecase)

7、创建internal/data/content.go文件

package data

import (
	"ContentManage/internal/biz"
	"context"
	"github.com/go-kratos/kratos/v2/log"
)

type contentRepo struct {
	data *Data
	log  *log.Helper
}

func NewContentRepo(data *Data, logger log.Logger) biz.ContentRepo {
	return &contentRepo{
		data: data,
		log:  log.NewHelper(logger),
	}
}

func (r *contentRepo) Create(ctx context.Context, content *biz.Content) error {
	r.log.Infof("contentRepo Create content = %+v", content)
	return r.data.db.Save(content).Error
}

8.修改internal/data/data.go文件

package data

import (
	"ContentManage/internal/conf"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"

	"github.com/go-kratos/kratos/v2/log"
	"github.com/google/wire"
)

// ProviderSet is data providers.
var ProviderSet = wire.NewSet(NewData, NewContentRepo)

// Data .
type Data struct {
	db *gorm.DB
}

// NewData .
func NewData(c *conf.Data, logger log.Logger) (*Data, func(), error) {
	cleanup := func() {
		log.NewHelper(logger).Info("closing the data resources")
	}
	mysqlDB, err := gorm.Open(mysql.Open(c.GetDatabase().Source))
	if err != nil {
		log.Error("[data] failed to connect database", "error", err)
		panic(err)
	}
	db, err := mysqlDB.DB()
	if err != nil {
		log.Error("[data] failed to connect database", "error", err)
		panic(err)
	}
	db.SetMaxOpenConns(4)
	db.SetMaxIdleConns(2)
	return &Data{
		db: mysqlDB,
	}, cleanup, nil
}

9、修改ContentManage/configs/config.yaml文件

server:
  http:
    addr: 0.0.0.0:8000
    timeout: 1s
  grpc:
    addr: 0.0.0.0:9000
    timeout: 1s
data:
  database:
    driver: mysql
    source: root:p@ssw0rd@tcp(127.0.0.1:3306)/?charset=utf8mb4&parseTime=True&loc=Local
  redis:
    addr: 127.0.0.1:6379
    read_timeout: 0.2s
    write_timeout: 0.2s

12、创建ContentManage/cmd/client/client.go，来rpc调用方法

package main

import (
	"ContentManage/api/operate"
	"context"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/middleware/recovery"
	"github.com/go-kratos/kratos/v2/transport/grpc"
)

func main() {
	conn, err := grpc.DialInsecure(
		context.Background(),
		grpc.WithEndpoint("127.0.0.1:9000"),
		grpc.WithMiddleware(recovery.Recovery()),
	)
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	client := operate.NewAppClient(conn)
	reply, err := client.CreateContent(context.Background(), &operate.CreateContentReq{
		Content: &operate.Content{
			Title:       "test content_manage create",
			VideoUrl:    "https://example.com/video.mp4",
			Author:      "lucky",
			Description: "test",
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	log.Infof("[grpc] CreateContent %v\n", reply)
}