go-kratos v2 + gorm 实现增删改查demo

由于正在学习Bilibili的go开源框架 go-kratos，简单学习的过程中有一些摸索过程，现在根据go-kratos v2 + gorm 实现增删改查demo实现用户的增删改查

mysql用户表

#sql

CREATE TABLE `user` (
  `id` int unsigned NOT NULL AUTO_INCREMENT,
  `name` char(20) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '名称',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='用户表';

项目初始化

0.文档地址

1.创建项目模板

kratos new user

cd user

2.拉取项目依赖

go mod download

3.生成proto模板

kratos proto add api/user/user.proto

这个时候我们去修改api/user/user.proto, 先仅仅实现用户新增功能,代码如下

syntax = "proto3";

package api.user.v1;

option go_package = "users/api/user/v1;v1";
option java_multiple_files = true;
option java_package = "api.user.v1";

import "google/api/annotations.proto";
// the validate rules:
// https://github.com/envoyproxy/protoc-gen-validate
import "validate/validate.proto";

service user {
  
    // 用户创建
    rpc CreateUser(CreateUserRequest) returns (CreateUserReply){
        option (google.api.http) = {
            post: "/v1/user"
            body: "*"
        };
    }


message User {
    int64 id = 1;
    string name = 2;
}

message CreateUserRequest {
    string name = 1 [(validate.rules).string = {min_len : 5, max_len: 50}];
}

message CreateUserReply {
    User User = 1;
}

proro文件中有参数校验,使用 proto-gen-validate 文档地址

4.生成proto源码 文档地址

kratos proto client api/user/user.proto

5.生成server模板

kratos proto server api/user/user.proto -t internal/service

coding阶段

打开 internal/service/user.go，代码如下：

package service

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

        pb "users/api/user/v1"
)

type UserService struct {
        pb.UnimplementedUserServer
        uc *biz.UserUseCase
        log *log.Helper
}

func NewUserService(uc *biz.UserUseCase, logger log.Logger) *UserService {
        return &UserService{uc:uc, log: log.NewHelper(logger)}
}

// 用户创建
func (s *UserService) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.CreateUserReply, error) {
        s.log.WithContext(ctx).Infof("CreateUser Received: %v", req)
        user := biz.User{
                Id:   0,
                Name: req.Name,
        }
        return &pb.CreateUserReply{}, s.uc.Create(ctx, &user)
}

打开 internal/service/service.go，代码如下：

package service

import "github.com/google/wire"

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

代码中引入了biz.User, 建立 ./internal/biz/user.go

package biz

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

type User struct {
        Id int64
        Name string
}

type UserRepo interface{
        CreateUser(ctx context.Context, user *User) error
}

type UserUseCase struct{
        repo UserRepo
        log *log.Helper
}

func NewUserUseCase(repo UserRepo, logger log.Logger) *UserUseCase {
        return &UserUseCase{repo:repo, log: log.NewHelper(logger)}
}
// 创建
func (uc *UserUseCase) Create(ctx context.Context, user *User) error {
        return uc.repo.CreateUser(ctx, user)
}

修改 ./internal/biz/biz.go

package biz

import "github.com/google/wire"

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

打开 ./internal/data/data.go

package data

import (
        "users/internal/conf"

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

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

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

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

// NewData .
func NewData(conf *conf.Data, logger log.Logger) (*Data, func(), error) {
        log :=  log.NewHelper(logger)
        // mysql数据库连接
        db, err := gorm.Open(mysql.Open(conf.Database.Source), &gorm.Config{});
        if err != nil {
                return nil, nil, err
        }

        d := &Data{
                db: db,
        }

        return d, func() {
                log.Info("message", "closing the data resources")
        }, nil
}

建立 ./internal/data/user.go

package data

import (
        "context"
        "errors"
        "github.com/go-kratos/kratos/v2/log"
        "gorm.io/gorm"
        "users/internal/biz"
        "users/internal/data/model"
)

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


func (u userRepo) CreateUser(ctx context.Context, user *biz.User) error {
        // 判断名称是否存在,存在则返回错误
        record := u.GetUserByName(user.Name)
        if record.Id != 0 {
                return errors.New("用户名已存在")
        }
        return u.data.db.Model(&model.User{}).Create(&model.User{
                Id:   0,
                Name: user.Name,
        }).Error
}

func NewUserRepo(data *Data, logger log.Logger) biz.UserRepo {
        return &userRepo{
                data: data,
                log:  log.NewHelper(logger),
        }
}

建立 ./internal/data/model/user.go

package model

type User struct{
        Id int64 `json:"id"`
        Name string `json:"name"`
}


func (User) TableName() string {
        return "user"
}

修改./internal/server/http.go

package server

import (
        "github.com/go-kratos/kratos/v2/log"
        "github.com/go-kratos/kratos/v2/middleware/logging"
        "github.com/go-kratos/kratos/v2/middleware/metrics"
        "github.com/go-kratos/kratos/v2/middleware/recovery"
        "github.com/go-kratos/kratos/v2/middleware/tracing"
        "github.com/go-kratos/kratos/v2/middleware/validate"
        "github.com/go-kratos/kratos/v2/transport/http"

        v1 "users/api/user/v1"
        "users/internal/conf"
        "users/internal/service"
)

// NewHTTPServer new a HTTP server.
func NewHTTPServer(c *conf.Server, user *service.UserService, logger log.Logger) *http.Server {
        var opts = []http.ServerOption{
                http.Middleware(
                        recovery.Recovery(),
                        tracing.Server(),
                        logging.Server(logger),
                        metrics.Server(),
                        validate.Validator(),
                ),
        }
        if c.Http.Network != "" {
                opts = append(opts, http.Network(c.Http.Network))
        }
        if c.Http.Addr != "" {
                opts = append(opts, http.Address(c.Http.Addr))
        }
        if c.Http.Timeout != nil {
                opts = append(opts, http.Timeout(c.Http.Timeout.AsDuration()))
        }
        srv := http.NewServer(opts...)
        v1.RegisterUserHTTPServer(srv, user)
        return srv
}

修改./internal/server/grpc.go

package server

import (
        "github.com/go-kratos/kratos/v2/log"
        "github.com/go-kratos/kratos/v2/middleware/logging"
        "github.com/go-kratos/kratos/v2/middleware/metrics"
        "github.com/go-kratos/kratos/v2/middleware/recovery"
        "github.com/go-kratos/kratos/v2/middleware/tracing"
        "github.com/go-kratos/kratos/v2/middleware/validate"
        "github.com/go-kratos/kratos/v2/transport/grpc"

        v1 "users/api/user/v1"
        "users/internal/conf"
        "users/internal/service"
)

// NewGRPCServer new a gRPC server.
func NewGRPCServer(c *conf.Server, user *service.UserService, logger log.Logger) *grpc.Server {
        var opts = []grpc.ServerOption{
                grpc.Middleware(
                        recovery.Recovery(),
                        tracing.Server(),
                        logging.Server(logger),
                        metrics.Server(),
                        validate.Validator(),
                ),
        }
        if c.Grpc.Network != "" {
                opts = append(opts, grpc.Network(c.Grpc.Network))
        }
        if c.Grpc.Addr != "" {
                opts = append(opts, grpc.Address(c.Grpc.Addr))
        }
        if c.Grpc.Timeout != nil {
                opts = append(opts, grpc.Timeout(c.Grpc.Timeout.AsDuration()))
        }
        srv := grpc.NewServer(opts...)
        v1.RegisterUserServer(srv, user)
        return srv
}

修改配置文件

打开 ./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: root@tcp(127.0.0.1:3306)/kratos_user?charset=utf8&parseTime=True&loc=Local
  redis:
    addr: 127.0.0.1:6379
    read_timeout: 0.2s
    write_timeout: 0.2s

项目编译

生成所有proto源码、wire等等

go generate ./...

运行项目

kratos run

发起请求 (postman)

POST localhost:8000/v1/user

{
    "name":"周周周周周"
}

以上是单个http接口请求,完整的增删改查自行下载

链接: https://pan.baidu.com/s/1mfUGAFr4YA3GtQUJ9Gd6TQ  密码: 2cma