Go-kratos框架商城微服务实战二

已于 2024-07-29 22:00:32 修改
阅读量535 收藏 5
点赞数 11
分类专栏： Go-kratos 文章标签： golang 微服务
于 2024-07-19 18:16:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73516381/article/details/140556947
版权

Go-kratos 框架商城微服务实战二

gorm 转成 ent

综合考虑之后，采用ent作为数据库 ORM 映射工具

  • ent命令建表
#默认在 ./ent/schema 下生成文件
ent new User
  • 设置表结构
package schema

import (
	"entgo.io/ent"
	"entgo.io/ent/schema/field"
	"entgo.io/ent/schema/index"
)

// User holds the schema definition for the User entity.
type User struct {
	ent.Schema
}

// Fields of the User.
func (User) Fields() []ent.Field {
	return []ent.Field{
		field.Int64("id").StorageKey("ID").Unique(),
		field.String("mobile").StorageKey("Mobile").Unique().NotEmpty().MaxLen(11).Comment("手机号码，用户唯一标识"),
		field.String("password").StorageKey("Password").NotEmpty().MaxLen(100).Comment("用户密码的保存需要注意是否加密"),
		field.String("nickname").StorageKey("NickName").MaxLen(25).Comment("用户昵称"),
		field.Time("birthday").StorageKey("Birthday").Nillable().Optional().Comment("出生日期"),
		field.String("gender").StorageKey("Gender").Default("male").MaxLen(16).Comment("female:女,male:男"),
		field.Int("role").StorageKey("Role").Default(1).Comment("1:普通用户,2:管理员"),
		field.Time("created_at").StorageKey("add_time").Optional(),
		field.Time("updated_at").StorageKey("update_time").Optional(),
		field.Bool("is_deleted").StorageKey("IsDeletedAt").Default(false),
	}
}

// Edges of the User.
func (User) Edges() []ent.Edge {
	return nil
}

// Indexes of the User. 
func (User) Indexes() []ent.Index {
	return []ent.Index{
		index.Fields("mobile").Unique(),
	}
}
  • 调整 /internal/data/data.go
package data

import (
	"context"
	"user/internal/conf"
	"user/internal/data/ent"

	"github.com/go-redis/redis/extra/redisotel"
	"github.com/go-redis/redis/v8"

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

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

// Data .
type Data struct {
	edb *ent.Client
	rdb *redis.Client
}

// NewData .
func NewData(c *conf.Data, logger log.Logger, edb *ent.Client, rdb *redis.Client) (*Data, func(), error) {
	cleanup := func() {
		log.NewHelper(logger).Info("closing the data resources")
	}
	return &Data{edb: edb, rdb: rdb}, cleanup, nil
}


func NewRedis(c *conf.Data) *redis.Client {
	rdb := redis.NewClient(&redis.Options{
		Addr:         c.Redis.Addr,
		Password:     c.Redis.Password,
		DB:           int(c.Redis.Db),
		DialTimeout:  c.Redis.DialTimeout.AsDuration(),
		WriteTimeout: c.Redis.WriteTimeout.AsDuration(),
		ReadTimeout:  c.Redis.ReadTimeout.AsDuration(),
	})
	rdb.AddHook(redisotel.TracingHook{})
	if err := rdb.Close(); err != nil {
		log.Error(err)
	}
	return rdb
}

func NeweDB(c *conf.Data) *ent.Client {
    client, err := ent.Open(c.Database.Driver, c.Database.Source)
    if err != nil {
        log.Errorf("failed opening connection to %s: %v", c.Database.Driver, err)
        panic("failed to connect database")
    }

    // 执行数据库模式创建或迁移
    ctx := context.Background()
    if err := client.Schema.Create(ctx); err != nil {
        log.Fatalf("failed creating schema resources: %v", err)
    }

    return client
}

新增 Update

  • 修改 /internal/data/user.go, 这里顺便新增UpdateUser,记得修改接口文件（user.proto）和/internal/biz/user.go
package biz

import (
	"context"

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

// User 定义返回数据结构体
type User struct {
	ID       int64
	Mobile   string
	Password string
	NickName string
	Birthday int64
	Gender   string
	Role     int
}

type UserRepo interface {
	CreateUser(context.Context, *User) (*User, error)
	UpdateUser(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, u *User) (*User, error) {
	return uc.repo.CreateUser(ctx, u)
}

func (uc *UserUsecase) Update(ctx context.Context, u *User) (*User, error) {
	return uc.repo.UpdateUser(ctx, u)
}

package data

import (
	"context"
	"crypto/sha512"
	"errors"
	"fmt"
	"time"
	"user/internal/biz"
	"user/internal/data/ent/user"

	"github.com/anaskhan96/go-password-encoder"
	"github.com/go-kratos/kratos/v2/log"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

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

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

// CreateUser .
func (r *userRepo) CreateUser(ctx context.Context, u *biz.User) (*biz.User, error) {
	// 检查 r.data 和 r.data.edb 不为 nil
	if r.data == nil || r.data.edb == nil {
		return nil, errors.New("data 或 edb 未初始化")
	}

	// 检查 u 不为 nil
	if u == nil {
		return nil, errors.New("传入的用户对象为 nil")
	}
	// 检查用户是否已存在
	exists, err := r.data.edb.User.
		Query().
		Where(user.MobileEQ(u.Mobile)).
		Exist(ctx)
	if err != nil {
		return nil, status.Errorf(codes.Internal, "查询用户失败: %v", err)
	}
	if exists {
		return nil, status.Errorf(codes.AlreadyExists, "用户已存在")
	}

	// 创建新用户
	hashedPassword := encrypt(u.Password) 

	entUser, err := r.data.edb.User.
		Create().
		SetMobile(u.Mobile).
		SetNickname(u.NickName).
		SetPassword(hashedPassword).SetRole(u.Role).
		Save(ctx)
	if err != nil {
		return nil, status.Errorf(codes.Internal, "创建用户失败: %v", err)
	}

	// 构造并返回业务层用户对象
	return &biz.User{
		ID:       entUser.ID,
		Mobile:   entUser.Mobile,
		Password: entUser.Password,
		NickName: entUser.Nickname,
		Gender:   entUser.Gender,
		Role:     entUser.Role,
	}, nil
}

func (r *userRepo) UpdateUser(ctx context.Context, u *biz.User) (*biz.User, error) {
	// 检查 r.data 和 r.data.edb 不为 nil
	if r.data == nil || r.data.edb == nil {
		return nil, errors.New("data 或 edb 未初始化")
	}

	// 检查 u 不为 nil
	if u == nil {
		return nil, errors.New("传入的用户对象为 nil")
	}

	// 检查用户是否存在
	entUser, err := r.data.edb.User.
		Query().
		Where(user.MobileEQ(u.Mobile)).
		First(ctx)
	if err != nil {
		return nil, status.Errorf(codes.Internal, "查询用户失败: %v", err)
	}
	if entUser == nil {
		return nil, status.Errorf(codes.NotFound, "用户不存在")
	}

	// 更新用户信息
	update := r.data.edb.User.UpdateOneID(entUser.ID)
	if u.NickName != "" {
		update.SetNickname(u.NickName)
	}
	if u.Password != "" {
		hashedPassword := encrypt(u.Password)
		update.SetPassword(hashedPassword)
	}
	if u.Gender != "" {
		update.SetGender(u.Gender)
	}
	if u.Role != 0 {
		update.SetRole(u.Role)
	}
	update.SetUpdatedAt(time.Now())
	entUser, err = update.Save(ctx)
	if err != nil {
		return nil, status.Errorf(codes.Internal, "更新用户失败: %v", err)
	}

	// 构造并返回业务层用户对象
	return &biz.User{
		ID:       entUser.ID,
		Mobile:   entUser.Mobile,
		Password: entUser.Password,
		NickName: entUser.Nickname,
		Gender:   entUser.Gender,
		Role:     entUser.Role,
	}, nil
}

// Password encryption
func encrypt(psd string) string {
	options := &password.Options{SaltLen: 16, Iterations: 10000, KeyLen: 32, HashFunction: sha512.New}
	salt, encodedPwd := password.Encode(psd, options)
	return fmt.Sprintf("$pbkdf2-sha512$%s$%s", salt, encodedPwd)
}
  • 接口文件修改
syntax = "proto3";

package api.user.v1;

option go_package = "user/api/user/v1;v1";
option java_multiple_files = true;
option java_package = "api.user.v1";
import "google/api/annotations.proto";
service User {
	rpc CreateUser (CreateUserRequest) returns (CreateUserReply) {
        option (google.api.http) = {
            post: "/v1/users"
            body: "*"
        };
    }
    rpc UpdateUser (UpdateUserRequest) returns (UpdateUserReply) {
        option (google.api.http) = {
            put: "/v1/users/{id}"
            body: "*"
        };
    }
    rpc DeleteUser (DeleteUserRequest) returns (DeleteUserReply) {
        option (google.api.http) = {
            delete: "/v1/users/{id}"
        };
    }
    rpc GetUser (GetUserRequest) returns (GetUserReply) {
        option (google.api.http) = {
            get: "/v1/users/{id}"
        };
    }
    rpc ListUser (ListUserRequest) returns (ListUserReply) {
        option (google.api.http) = {
            get: "/v1/users"
        };
    }
}

message CreateUserRequest {
	string nickName = 1;
	string password = 2;
	string mobile = 3;
}
message CreateUserReply {
	int64 id = 1;
	string password = 2;
	string mobile = 3;
	string nickName = 4;
	int64 birthday = 5;
	string gender = 6;
	int32 role = 7;
}

message UpdateUserRequest {
	int64 id = 1;
	string password = 2;
	string mobile = 3;
	string nickName = 4;
	int64 birthday = 5;
	string gender = 6;
	int32 role = 7;
}
message UpdateUserReply {
    int64 id = 1;
	string password = 2;
	string mobile = 3;
	string nickName = 4;
	int64 birthday = 5;
	string gender = 6;
	int32 role = 7;
}

message DeleteUserRequest {
	int64 id = 1;
}
message DeleteUserReply {}

message GetUserRequest {
	int64 id = 1;
}
message GetUserReply {}

message ListUserRequest {}
message ListUserReply {}
  • 修改对应 service 层, /internal/service/user.go
package service

import (
	"context"
	v1 "user/api/user/v1"
	"user/internal/biz"

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

type UserService struct {
	v1.UnimplementedUserServer

	uc  *biz.UserUsecase
	log *log.Helper
}

// NewUserService new a greeter service.
func NewUserService(uc *biz.UserUsecase, logger log.Logger) *UserService {
	return &UserService{uc: uc, log: log.NewHelper(logger)}
}

// CreateUser create a user
func (u *UserService) CreateUser(ctx context.Context, req *v1.CreateUserRequest) (*v1.CreateUserReply, error) {
	// 记录请求信息，注意避免记录敏感信息如密码
	u.log.Info(" Creating user ", " mobile:", req.Mobile, " nickname:", req.NickName)

	user, err := u.uc.Create(ctx, &biz.User{
		Mobile:   req.Mobile,
		Password: req.Password,
		NickName: req.NickName,
	})
	if err != nil {
		u.log.Error("Failed to create user", "error", err)
		return nil, err
	}

	userInfoRsp := v1.CreateUserReply{
		Id:       user.ID,
		Mobile:   user.Mobile,
		Password: user.Password,
		NickName: user.NickName,
		Gender:   user.Gender,
		Role:     int32(user.Role),
		Birthday: user.Birthday,
	}

	return &userInfoRsp, nil
}

func (u *UserService) UpdateUser(ctx context.Context, req *v1.UpdateUserRequest) (*v1.UpdateUserReply, error) {
	u.log.Info(" Updating user ", " mobile:", req.Mobile, " nickname:", req.NickName, "Gender:",req.Gender)
 
	user, err := u.uc.Update(ctx, &biz.User{
		Mobile:   req.Mobile,
		Password: req.Password,
		NickName: req.NickName,
		Gender:   req.Gender,
		Role: int(req.Role),
	})
	if err != nil {
		u.log.Error("Failed to update user", "error", err)
		return nil, err
	}

	userInfoRsp := v1.UpdateUserReply{
		Id:       user.ID,
		Mobile:   user.Mobile,
		Password: user.Password,
		NickName: user.NickName,
		Gender:   user.Gender,
		Role:     int32(user.Role),
		Birthday: user.Birthday,
	}

	return &userInfoRsp, nil
}
Zyxalia
关注
专栏目录
kratos 微服务框架商城实战初识 kratos
Sdj356512265的博客
03-30 1726
准备工作 本机器这里已经安装好了 go、kratos、proto、wire、make等所需的工具。 初始化项目目录 进入自己电脑中存放 Go 项目的目录 新建 kratos-shop/service目录，并进入到新建的目录中 执行 kratos new user命令并进入 user目录，执行命令 kratos proto add api/user/v1/user.proto， 这时你在 /service/user/api/user/v1目录下会看到新的 user.proto文件已经...
Go微服务框架go-kratos实战04：kratos中服务注册和服务发现的使用
xuhss_com的博客
06-04 2375
关于服务注册和服务发现介绍，我前面的文章有介绍过 - 服务注册和发现的文章。作为服务中心的软件有很多，比如 etcd，consul，nacos，zookeeper 等都可以作为服务中心。go-kratos 把这些服务中心的功能作为插件，集成进了 kratos 中。下面就用 etcd 作为服务中心来说说 kratos 里服务注册和服务发现功能的使用。从 go-kratos 服务注册和发现文档中，我们知道它的接口定义非常简单：注册和反注册服务： 获取服务： 2.2 简单使用 服务端注册服务 使用 etcd 作为
Go-Kratos是bilibili开源的一套Go微服务框架包含大量微服务相关框架及工具。
08-13
Kratos是bilibili开源的一套Go微服务框架，包含大量微服务相关框架及工具。
Go-kratos框架商城微服务实战一
m0_73516381的博客
07-16 378
本文档介绍了使用 Go-kratos 框架构建商城微服务的步骤。首先，初始化项目目录并创建用户服务。然后，通过定义 `user.proto` 文件来描述用户服务的接口，并生成相应的客户端和服务端代码。
Kratos框架单体应用实战四
临缘之空的专栏
09-06 1011
项目框架和基本的逻辑实现后，我们就可以先把项目部署起来，开发的最后一个链路实现。本篇文章主要是介绍利用单体应用如何在单台服务器上部署的方式，可以使用supervisor工具，dockerfile文件，docker-compose文件等方式部署，一般来说，mysql和redis都是分开在单独的容器中或购买的单独数据库资源，上述例子只是在开发和测试中使用较多。
Go framework-Kratos
杀神lwz的博客
08-23 1267
Web framework-GinGo framework-BeegoGolang学习+深入(一)年轻不怕输！谁能比别人领先一步掌握新技术，谁就在竞争中赢得了先机。
go kratos 微服务框架（笔记一）
jkwanga的博客
12-14 2717
kratos 微服务框架学习笔记
推荐使用：Go Kratos——强大而灵活的微服务框架
gitblog_00001的博客
05-10 514
推荐使用：Go Kratos——强大而灵活的微服务框架 kratosYour ultimate Go microservices framework for the cloud-native era.项目地址:https://gitcode.com/gh_mirrors/krato/kratos 项目简介 在构建高可用、高性能的微服务应用时，你需要一个强大且稳定的工具，这就是Go Kratos。...
【kratos入门实战教程】1-kratos项目搭建和开发环境配置
Reach的博客
08-03 4715
【kratos入门实战教程】kratos环境搭建篇
go微服务框架Kratos笔记「链路追踪实战」
l688899886的博客
06-22 750
借用阿里云链路追踪文档来解释 分布式链路追踪（Distributed Tracing），也叫 分布式链路跟踪，分布式跟踪，分布式追踪 等等，它为分布式应用的开发者提供了完整的调用链路还原、调用请求量统计、链路拓扑、应用依赖分析等工具，可以帮助开发者快速分析和诊断分布式应用架构下的性能瓶颈，提高微服务时代下的开发诊断效率。 为了应对各种复杂的业务，开发工程师开始采用敏捷开发、持续集成等开发方式。系统架构也从单机大型软件演化成微服务架构。微服务构建在不同的软件集上，这些软件模块可能是由不同团队开发的，可能使用不
go微服务框架kratos学习笔记三(构建单独的http或者rpc demo项目)
01-08
文章目录go微服务框架kratos学习笔记三(构建单独的http或者grpc demo项目)grpchttp go微服务框架kratos学习笔记三(构建单独的http或者grpc demo项目) 前面两篇跑通了demo项目，和大概了解了kratos demo整体结构，本篇分别构建一个http和一个grpc微服务单独测试。 grpc 先从grpc 开始， 上篇没有测试grpc接口，这回来尝试，直接跑起demo 服务。 kratos new rpcdemo --grpc kratos run INFO 12/26-20:49:08.933 I:/VSProject/kratos/rpcdemo/
B站微服务框架Kratos详细教程(5)-gRPC 示例项目源码
09-10
B站微服务框架Kratos详细教程(5)-gRPC 示例项目源码 博文地址：https://blog.csdn.net/uisoul/article/details/108490259
基于Golang+Kratos+MySQL+Redis+Kafka+elk+Opentracing实现的微服务项目
07-28
基于Golang+Kratos+MySQL+Redis+Kafka+elk+Opentracing实现的微服务项目
B站微服务框架Kratos详细教程(2)-HTTP服务项目源码
09-08
B站微服务框架Kratos详细教程(2)-HTTP服务 示例项目源码 博文地址：https://blog.csdn.net/uisoul/article/details/108455395
Kratos框架单体应用实战一
临缘之空的专栏
08-26 421
Kratos框架是一套轻量级 Go 微服务框架，包含大量微服务相关框架及工具。之所以是轻量级是因为框架内部并没有重写很多其他开源库已经实现的功能，而是提供了一套规范和接口，并且在此基础上提供了对这些开源库的整合和统一接口的定义，你可以很容易的将gin，gorm,go-redis等开源库集成进来，方便扩展与维护。
初步了解Kratos，走进战神框架
最新发布
youm2003的博客
09-11 1087
Kratos 一套轻量级 Go 微服务框架，包含大量微服务相关框架及工具。
笔者带你剖析轻量级Sharding中间件——Kratos1.x
gao_xianglong的自言自语
08-22 245
《笔者带你剖析轻量级Sharding中间件——Kratos1.x》   之所以编写Kratos其实存在一个小插曲，当笔者满山遍野寻找成熟、稳定、高性能的Sharding中间件时，确实是翻山越岭，只不过始终没有找到一款合适笔者项目场景的中间件产品。依稀记得当年第一款使用的Sharding中间件就是淘宝的TDDL3.0，只可惜现在拿不到源码。而其它的中间件，大多都是基于Proxy的，相信做过分...
Go最新kratos学习(二) kratos配置_kartos，2024年最新OMG，2024年最新学它
2401_84910880的博客
05-17 1192
框架内置了和的实现。另外，在如果上述的配置加载方式无法涵盖您的环境，您也可以通过实现接口来适配您自己的配置加载方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值