Go-zero框架学习+xorm+gorm配置

Go-zero框架学习+xorm+gorm配置

文章目录

  • Go-zero框架学习+xorm+gorm配置
  • 一、框架介绍
  • 二、go-zero快速搭建
    • 1.下载go-zero
    • 2.安装goctl
    • 3.项目初始化
    • 4.测试
    • 5.项目结构
    • 6.快速生成rpc服务
    • 7.快速添加api接口
    • 8.快速生成model服务
    • 8.快速生成Dockerfile
    • 9.快速生成K8s部署文件
  • 三.golang的ORM框架
  • 四. go-zero配置xorm和redis
    • 1.配置文件
    • 2.修改config
    • 3.修改serviceContext文件
    • 4.初始化Init方法
    • 5.logic业务逻辑调用
  • 五.go-zero配置gorm
    • 2.修改servicecontext.go文件
    • 3.修改greet.api文件
    • 4.修改logic文件
    • 5.运行测试
  • 六、go-zero架构设计-作者万俊峰的讲解
    • go-zero架构特点
    • 其他说明


一、框架介绍

go-zero 包含极简的 API 定义和生成工具 goctl,可以根据定义的 api 文件一键生成 Go, iOS, Android, Kotlin, Dart, TypeScript, JavaScript 代码,并可直接运行。

goctl是go-zero微服务框架下的代码生成工具。使用 goctl 可显著提升开发效率,让开发人员将时间重点放在业务开发上,其功能有:api服务生成,rpc服务生成,model代码生成,模板管理等。

protoc是一款用C++编写的工具,其可以将proto文件翻译为指定语言的代码。在go-zero的微服务中,我们采用grpc进行服务间的通信,而grpc的编写就需要用到protoc和翻译成go语言rpc stub代码的插件protoc-gen-go。

二、go-zero快速搭建

这节内容部分参考资料
go-zero框架简介与基本使用 - Abel Chan的文章 - 知乎

1.下载go-zero

get -u github.com/zeromicro/go-zero

2.安装goctl

go 1.15及以前版本:

go get -u github.com/zeromicro/go-zero/tools/goctl@latest

go 1.16 及以后版本:

go install github.com/zeromicro/go-zero/tools/goctl@latest

查看goctl版本

goctl -v

3.项目初始化

// 创建API服务
goctl api new greet
cd greet
go mod init
go mod tidy
// 启动服务
go run greet.go -f etc/greet-api.yaml

4.测试

访问: http://127.0.0.1:8888/from/you

或者linux
curl -i http://127.0.0.1:8888/from/you

备注:
默认启动端口号:8888
修改配置文件/etc/greet-api.yaml 可以修改端口号

5.项目结构

|____go.mod
|____etc //存放配置文件
| |____greet-api.yaml
|____internal
| |____handler // 路由与处理器
| | |____routes.go
| | |____greethandler.go
| |____types //中间类型
| | |____types.go
| |____config // 配置-对应etc下配置文件
| | |____config.go
| |____logic //逻辑处理
| | |____greetlogic.go
| |____svc //依赖资源
| | |____servicecontext.go
|____go.sum
|____greet.api //api接口与类型定义
|____greet.go //main.go 入口

6.快速生成rpc服务

使用proto文件自动生成
方式1:创建rpc服务

goctl rpc new greet

生成greet.proto文件如下

syntax = "proto3";

package rpc-greet;
option go_package="./rpc-greet";

message Request {
  string ping = 1;
}

message Response {
  string pong = 1;
}

service Rpc-Greet {
  rpc Ping(Request) returns(Response);
}

方式2:
通过定义好的proto文件,生成相应的rpc服务

goctl rpc template -o=userinfo.proto

userinfo.proto内容如下

syntax = "proto3";  //指定版本信息,不指定会报错,默认proto2
//option go_package = "./proto;userinfo";  // 分号后面是包名
option go_package = "./userService";

message userinfo{
    string username = 1;
    int32 age = 2;
    repeated string hobby = 3; //数组,golang对应string切片
}
// 转成go文件protoc --go_out=./ *.proto 

7.快速添加api接口

修改greet.api文件

service greet-api {
    @handler UserLogin
	post /user/login(LoginRequest) returns (LoginReply)
}
@server (
	middleware: Auth
)
service core-api{
	// 文件上传
	@handler FileUpload
	post /file/upload(FileUploadRequest) returns (FileUploadReply)	
}
type LoginRequest {
	Name     string `json:"name"`
	Password string `json:"password"`
}
	
type LoginReply {
	Token string `json:"token"`
}
type FileUploadRequest {
	Hash string `json:"hash,optional"`
	Name string `json:"name,optional"`
	Ext string `json:"ext,optional"`
	Size int64 `json:"size,optional"`
	Path string `json:"path,optional"`
}
	
type FileUploadReply {
	Identity string `json:"identity"`
	Ext string `json:"ext"`
	Name string `json:"name"`
}

自动生成代码

goctl api go -api greet.api -dir . 

或者
goctl api go -api greet.api -dir . -style go_zero

备注:
-style go_zero:自动生成的文件名使用下划线进行分隔,如:
service_context.go
user_file_delete_logic.go

生成代码后的文件结构如下:

自动生成handler文件和logic文件
|____go.mod
|____etc
| |____greet-api.yaml
|____internal
| |____handler
| | |____userhandler.go // 新增handler
| | |____routes.go
| | |____greethandler.go
| |____types
| | |____types.go // 新增type都在这里
| |____config
| | |____config.go
| |____logic
| | |____userlogic.go //新增的logic文件,处理具体业务逻辑
| | |____greetlogic.go
| |____svc
| | |____servicecontext.go
|____go.sum
|____greet.api
|____greet.go

8.快速生成model服务

方式1:通过ddl生成

goctl mysql goctl model mysql ddl -src="./*.sql" -dir="../" -c=true

备注:
-c : 是否加缓存

方式2:通过datasource生成

goctl model mysql datasource -url="user:password@tcp(127.0.0.1:3306)/database" -table="*" -dir="./"

生成文件示例
.
|____tdfsubscriptionmodel.go
|____vars.go
|____diversionrulesmodel.go
|____sql
| |____sub.sql

8.快速生成Dockerfile

goctl docker -go greet.go
.
|____go.mod
|____Dockerfile // 当前服务的Dockerfile文件
|____etc
| |____greet-api.yaml
|____internal
| |____handler
| | |____userhandler.go
| | |____routes.go
| | |____greethandler.go
| |____types
| | |____types.go
| |____config
| | |____config.go
| |____logic
| | |____userlogic.go
| | |____greetlogic.go
| |____svc
| | |____servicecontext.go
|____go.sum
|____greet.api
|____greet.go

9.快速生成K8s部署文件

goctl kube deploy -name redis -namespace adhoc -image redis:6-alpine -o redis.yaml -port 6379

生成的redis.yaml文件

三.golang的ORM框架

golang常用的几种orm框架,主流框架包括:

  • gorm
  • xorm
  • upper/db
  • gorose
  • worm
    接下来将针对如何配置xorm和gorm进行说明,新手入门项目,可以选择xorm或者gorm其中的一个作为选型;

四. go-zero配置xorm和redis

这块内容基于B站实战视频学习所得
【【项目实战】基于Go-zero、Xorm的网盘系统】

1.配置文件

/etc/core-api.yaml
增加mysql和redis的配置

Name: core-api
Host: 0.0.0.0
Port: 8888

Mysql:
  DataSource: root:password@tcp(127.0.0.1:3306)/cloud_disk?charset=utf8mb4&parseTime=True&loc=Local

Redis:
  Addr: 127.0.0.1:6379

2.修改config

/internal/config/config.go

package config

import "github.com/zeromicro/go-zero/rest"

type Config struct {
	rest.RestConf
	Mysql struct {
		DataSource string
	}
	Redis struct {
		Addr string
	}
}

3.修改serviceContext文件

/internal/svc/service_context.go
增加Engine和RDB

package svc

import (
	"cloud-disk/core/internal/config"
	"cloud-disk/core/models"
	"github.com/go-redis/redis/v8"
	"github.com/zeromicro/go-zero/rest"
	"xorm.io/xorm"
)

type ServiceContext struct {
	Config config.Config
	Engine *xorm.Engine
	RDB    *redis.Client
}

func NewServiceContext(c config.Config) *ServiceContext {
	return &ServiceContext{
		Config: c,
		Engine: models.Init(c.Mysql.DataSource),
		RDB:    models.InitRedis(c),
	}
}

4.初始化Init方法

/models/init.go

package models

import (
	"cloud-disk/core/internal/config"
	"log"

	"github.com/go-redis/redis/v8"
	_ "github.com/go-sql-driver/mysql"
	"xorm.io/xorm"
)

func Init(dataSource string) *xorm.Engine {
	engine, err := xorm.NewEngine("mysql", dataSource)
	if err != nil {
		log.Printf("Xorm New Engine Error : %v", err)
		return nil
	}
	return engine
}

func InitRedis(c config.Config) *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:     c.Redis.Addr,
		Password: "", // no password set
		DB:       0,  // use default DB
	})
}

5.logic业务逻辑调用

func (l *UserRegisterLogic) UserRegister(req *types.UserRegisterRequest) (resp *types.UserRegisterReply, err error) {
	// 调用redis获取验证码
	// 判断code是否一致
	code, err := l.svcCtx.RDB.Get(l.ctx, req.Email).Result()
	if err != nil {
		err = errors.New("该邮箱验证码为空")
		return nil, err
	}

	if code != req.Code {
		err = errors.New("验证码错误")
		return
	}

    // 使用xorm查询数据库
	// 判断用户名是否存在
	cnt, err := l.svcCtx.Engine.Where("name = ?", req.Name).Count(new(models.UserBasic))
	if err != nil {
		return nil, err
	}

	if cnt > 0 {
		err = errors.New("用户名已存在")
		return nil, err
	}

	user := &models.UserBasic{
		Identity: helper.UUID(),
		Name:     req.Name,
		Password: helper.Md5(req.Password),
		Email:    req.Email,
	}

	n, err := l.svcCtx.Engine.Insert(user)
	if err != nil {
		return nil, err
	}
	log.Println("insert user row:", n)
	res := &types.UserRegisterReply{}
	res.Message = "注册成功"
	return
}


五.go-zero配置gorm

这节内容参考了博客
【go-zero之gozero+gorm】

1、配置文件
/etc/greet-api.yaml增加数据库连接配置DataSourceName

Name: greet-api
Host: 0.0.0.0
Port: 8888

DataSourceName: root:password@tcp(127.0.0.1:3306)/cloud_disk?charset=utf8mb4&parseTime=True&loc=Local

/internal/config/config.go增加DataSourceName

type Config struct {
	rest.RestConf
	DataSourceName string
}

2.修改servicecontext.go文件

/internal/svc/servicecontext.go

package svc

import (
	"greet/internal/config"
	"greet/internal/models"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
)

type ServiceContext struct {
	Config  config.Config
	DbEngine *gorm.DB
}

func NewServiceContext(c config.Config) *ServiceContext {
	db, err := gorm.Open(mysql.Open(c.DataSourceName), &gorm.Config{
		NamingStrategy: schema.NamingStrategy{
			//TablePrefix:   "tech_", // 表名前缀,`User` 的表名应该是 `t_users`
			SingularTable: true,    // 使用单数表名,启用该选项,此时,`User` 的表名应该是 `t_user`
		},
	})
	//如果出错就GameOver了
	if err != nil {
		panic(err)
	}
	//自动同步更新表结构,不要建表了O(∩_∩)O哈哈~
	db.AutoMigrate(&models.User{})

	return &ServiceContext{
		Config:  c,
		DbEngine: db,
	}
}

3.修改greet.api文件

type RegisterRequest {
	Mobile string `json:"mobile"`
	Password string `json:"password"`
}
type RegisterResponse {
	Id int `json:"id"`
}

service greet-api {
	@handler Register
	post /register(RegisterRequest) returns (RegisterResponse)
}

使用代码生成

goctl api go -api greet.api -dir .

生成/logic/registerlogic.go

4.修改logic文件

/logic/registerlogic.go

func (l *RegisterLogic) Register(req *types.RegisterRequest) (resp *types.RegisterResponse, err error) {
	user := models.User{
		Mobile:   req.Mobile,
		Password: req.Password,
	}
	result := l.svcCtx.DbEngine.Create(&user)
	return &types.RegisterResponse{
		Id: user.Id,
	}, result.Error
}

/internal/models/user.go

package models

import (
	"errors"
	"greet/internal/utils"

	"gorm.io/gorm"
)

type User struct {
	gorm.Model
	Id       int `gorm:"type:int(64)"`
	Mobile   string `gorm:"index:mobile;type:varchar(13)"`
	Password string `gorm:"type:varchar(64)"`
}

// 在创建前检验验证一下密码的有效性
func (u *User) BeforeCreate(db *gorm.DB) error {
	if len(u.Password) < 6 {
		return errors.New("密码太简单了")
	}
	//对密码进行加密存储
	u.Password = utils.Password(u.Password)
	return nil
}

/internal/utils/password.go 工具方法

package utils

import (
	"fmt"

	"golang.org/x/crypto/bcrypt"
)

// 密码加密
func Password(plainpwd string) string {
	//谷歌的加密包
	hash, err := bcrypt.GenerateFromPassword([]byte(plainpwd), bcrypt.DefaultCost) //加密处理
	if err != nil {
		fmt.Println(err)
	}
	encodePWD := string(hash) // 保存在数据库的密码,虽然每次生成都不同,只需保存一份即可
	return encodePWD
}

// 密码校验
func CheckPassword(plainpwd, cryptedpwd string) bool {
	err := bcrypt.CompareHashAndPassword([]byte(cryptedpwd), []byte(plainpwd)) //验证(对比)
	return err == nil
}

数据表设计如下
user表
Go-zero框架学习+xorm+gorm配置_第1张图片

5.运行测试

运行服务

go mod tidy
go run greet.go -f etc/greet-api.yaml

postman发送请求
http://127.0.0.1:8888/register
参数

{
    "mobile": "123233123123",
    "password":"111234311"
}

Go-zero框架学习+xorm+gorm配置_第2张图片

查看数据表
Go-zero框架学习+xorm+gorm配置_第3张图片
数据添加成功


六、go-zero架构设计-作者万俊峰的讲解

原视频链接:
【#101 晓黑板 go-zero 微服务框架的架构设计】

go-zero架构特点

1、进程内限流

  • 控制并发请求
  • 简单高效
  • 可配置,有默认值
  • 有效防止突发恶意流量
  • 第一道防护(WAF等除外)

2、分布式限流

  • 基于redis/lua
  • 令牌桶
  • 漏桶
  • 广泛使用,短信、推送等

3、基于优先级进行分级降载保护

  • K8S的HPA 80%触发
  • CPU>90%开始拒绝低优先级请求
  • CPU>95%开始拒绝高优先级请求
  • http/rpc框架内建
  • 基于滑动窗口,防止毛刺
  • 有冷却时间,防止抖动
  • 实践检验,配合K8S弹性伸缩
  • 第二道防护

4、路径级别的自适应熔断

  • 自动触发,自动恢复
  • http/rpc框架内建
  • Google SRE算法
  • 放弃了Netfix Hystrix算法
  • 基于滑动窗口(10秒/40秒窗口)
  • 支持自定义触发条件
  • 支持自定义fallback
  • 第三道防护

其他说明

1、多重防护,保障高可用
请求–》并发控制、限流–》自适应降载、K8S弹性伸缩 --》自适应熔断、负载均衡

2、重试机制
不自动重试

重试注意事项:

  • 指数退避
  • 流量quota
  • 超时相关性

3、缓存设计三要点

  • 缓存穿透,不存在的数据
  • 缓存击穿,热点key过期
  • 缓存雪崩,大量缓存同时过期

4、缓存解决办法

  • 缓存穿透:即使查不到,也自动缓存,短过期时间,1分钟
  • 缓存击穿:确保一个进程同时只拿一次数据,并共享结果
  • 缓存雪崩:针对缓存过期时间设置随机偏差,确保分散过期
  • 缓存基于非主键查询:转换为主键做缓存;获取复杂,查询->主键->缓存
  • 分布式缓存:多虚拟节点一致性hash,避免降级后过多cache miss

5、可观测性

  • 链路跟踪
  • Logging
  • Metrics
  • 监控报警

(1)链路跟踪

  • 框架自建,context传递
  • Trace id, 贯穿整个调用链
  • Span id, 有层级和时序关系
  • 记录起止时间
  • 记录调用关系,client/server

(2)Logging

  • 自动rotate
  • 多模式支持,console,file,volume
  • 自动压缩
  • 自动删除过期日志

(3)监控报警

  • 自动聚合汇报异常,比如http code 5xx
  • 自动控制频率并汇总异常

6、数据上报

  • 上报到控制台服务
  • 上报到prometheus

7、其他

  • 基于JWT的自动鉴权
  • MapReduce
  • Graceful shutdown
  • 并发控制工具箱
  • 资源控制工具箱,比如多个线程同时创建同一个数据库链接
  • 分布式高可用延迟任务框架
  • 极简Kafka Pub/Sub框架
  • Logstash 5倍性能的go-stash框架

你可能感兴趣的:(golang,golang,学习,开发语言)