从零开始实现基于go-zero框架的微服务电商项目（三）——gorm、redis、腾讯云SMS、validate、md5加密、日志输入到kafka的添加

从零开始实现基于go-zero框架的微服务电商项目（三）——gorm、redis、腾讯云SMS、validate、md5加密、日志输入到kafka的添加

项目地址：liuxianloveqiqi/XianShop: 使用go-zero搭建的电商项目 (github.com)

开始

我们在service里面新建一个utils包，里面就放上面的一些加入

gorm和redis的初始化

在common包下新建文件init_system.go，添加：

package common

import (
    "context"
    "fmt"
    "github.com/redis/go-redis/v9"
    "github.com/zeromicro/go-zero/core/logx"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "gorm.io/gorm/schema"
)

// gorm初始化
func InitGorm(MysqlDataSourece string) *gorm.DB {
    // 将日志写进kafka
    logx.SetWriter(*LogxKafka())
    db, err := gorm.Open(mysql.Open(MysqlDataSourece),
       &gorm.Config{
          NamingStrategy: schema.NamingStrategy{
             //TablePrefix:   "tech_", // 表名前缀，`User` 的表名应该是 `t_users`
             SingularTable: true, // 使用单数表名，启用该选项，此时，`User` 的表名应该是 `t_user`
          },
       })
    if err != nil {
       panic("连接mysql数据库失败, error=" + err.Error())
    } else {
       fmt.Println("连接mysql数据库成功")
    }
    return db
}

// redis初始化
func InitRedis(add, password string, db int) *redis.Client {
​    rdb := redis.NewClient(&redis.Options{
​       Addr:     add,
​       Password: password,
​       DB:       db,
​    })
​    _, err := rdb.Ping(context.Background()).Result()
​    if err != nil {
​       panic("连接redis失败, error=" + err.Error())
​    }
​    fmt.Println("redis连接成功")
​    return rdb
}

日志输出到kafka

请参考官方：logx | go-zero

在common包下建kafka_logx.go，我这里就是封装了一下官方的写法：

package common

import (
	"github.com/zeromicro/go-queue/kq"
	"github.com/zeromicro/go-zero/core/logx"
	"strings"
)

type KafkaWriter struct {
	Pusher *kq.Pusher
}

func NewKafkaWriter(pusher *kq.Pusher) *KafkaWriter {
	return &KafkaWriter{
		Pusher: pusher,
	}
}

func (w *KafkaWriter) Write(p []byte) (n int, err error) {
	// writing log with newlines, trim them.
	if err := w.Pusher.Push(strings.TrimSpace(string(p))); err != nil {
		return 0, err
	}

	return len(p), nil
}
func LogxKafka() *logx.Writer {
	pusher := kq.NewPusher([]string{"localhost:9092"}, "log")
	defer pusher.Close()

	writer := logx.NewWriter(NewKafkaWriter(pusher))
	return &writer
}

==注意!==下面都是先在rpc里面写，然后api直接调自己的rpc，所以业务处理部分是在rpc里面写的,api直接调就行。

接着在user/rpc下的config里面添加redis和gorm

package config

import (
	"github.com/zeromicro/go-zero/core/stores/cache"
	"github.com/zeromicro/go-zero/zrpc"
)

type Config struct {
	zrpc.RpcServerConf
	Mysql struct {
		DataSource string
	}
	CacheRedis cache.CacheConf
	Redis      struct {
		Host string
		Pass string
		DB   int
	}
	Credential struct {
		SecretId  string
		SecretKey string
	}
}

在svc下的servicecontext.go下添加gorm和redis并调用common里面的初始化

package svc

import (
	"XianShop/service/common"
	"XianShop/service/user/model"
	"XianShop/service/user/rpc/internal/config"
	"github.com/redis/go-redis/v9"

	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"gorm.io/gorm"
)

type ServiceContext struct {
	Config    config.Config
	UserModel model.UserModel
	Rdb       *redis.Client
	DbEngine  *gorm.DB
}

func NewServiceContext(c config.Config) *ServiceContext {
	coon := sqlx.NewMysql(c.Mysql.DataSource)
	db := common.InitGorm(c.Mysql.DataSource)
	rdb := common.InitRedis(c.Redis.Host, c.Redis.Pass, c.Redis.DB)
	db.AutoMigrate(&model.User{})
	return &ServiceContext{
		Config:    c,
		UserModel: model.NewUserModel(coon, c.CacheRedis),
		Rdb:       rdb,
		DbEngine:  db,
	}
}

这样之后我们就可以在logic里面调用gorm和redis

腾讯云SMS短信服务

首先在腾讯云搜索sms点击短信，按照指引创造好模版等待审核，完成后根据官方文档配置：

在utils包下建sms.go

package utils

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/redis/go-redis/v9"
	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
	sms "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/sms/v20210111"
	"math/rand"
	"strings"
	"time"
)

func SMS(phone, secretId, secretKey string, ctx context.Context, rdb *redis.Client) string {
	// 实例化一个认证对象，入参需要传入腾讯云账户密钥对secretId,secretKey.
	credential := common.NewCredential(
		secretId,
		secretKey,
	)

	// 实例化一个认证对象，入参需要传入腾讯云账户密钥对secretId,secretKey.
	//credential := common.NewCredential(
	//	"你的accessKeyId",
	//	"你的accessKeySecret",
	//)
	cpf := profile.NewClientProfile()

	cpf.HttpProfile.ReqMethod = "POST"

	cpf.HttpProfile.Endpoint = "sms.tencentcloudapi.com"

	client, _ := sms.NewClient(credential, "ap-beijing", cpf)

	/* 实例化一个请求对象，根据调用的接口和实际情况*/
	request := sms.NewSendSmsRequest()

	// 应用 ID 可前往 [短信控制台](https://console.cloud.tencent.com/smsv2/app-manage) 查看
	request.SmsSdkAppId = common.StringPtr("1400797992")

	// 短信签名内容: 使用 UTF-8 编码，必须填写已审核通过的签名
	request.SignName = common.StringPtr("我的学习记录网")

	/* 模板 ID: 必须填写已审核通过的模板 ID */
	request.TemplateId = common.StringPtr("1729324")

	/* 模板参数: 模板参数的个数需要与 TemplateId 对应模板的变量个数保持一致，若无模板参数，则设置为空*/
	code1 := GenerateSmsCode(6)
	fmt.Println(code1, "ZHESHICODE")
	request.TemplateParamSet = common.StringPtrs([]string{code1, "3"})
	/* 下发手机号码，采用 E.164 标准，+[国家或地区码][手机号]
	 * 示例如：+8613711112222， 其中前面有一个+号 ，86为国家码，13711112222为手机号，最多不要超过200个手机号*/
	phoneWithPrefix := "+86" + phone
	request.PhoneNumberSet = common.StringPtrs([]string{phoneWithPrefix})
	//使用redis缓存
	rdb.Set(ctx, phone, code1, 3*time.Minute)
	fmt.Println(phone, "  ", code1)
	// 通过client对象调用想要访问的接口，需要传入请求对象
	response, err := client.SendSms(request)
	// 处理异常
	if _, ok := err.(*errors.TencentCloudSDKError); ok {
		fmt.Printf("An API error has returned: %s", err)
		return ""
	}
	// 非SDK异常，直接失败。实际代码中可以加入其他的处理。
	if err != nil {
		panic(err)
	}
	b, _ := json.Marshal(response.Response)
	// 打印返回的json字符串
	fmt.Printf("%s", b)
	return code1
}

// GenerateSmsCode 生成验证码;length代表验证码的长度
func GenerateSmsCode(length int) string {
	numberic := [10]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	rand.Seed(time.Now().Unix())
	var sb strings.Builder
	for i := 0; i < length; i++ {
		fmt.Fprintf(&sb, "%d", numberic[rand.Intn(len(numberic))])
	}
	return sb.String()
}

然后改成自己的：

红色的地方是根据自己的情况可以改动的，最后那个模版参数那里，是有几个参数填几个，一一对应的关系，比如我的模版是这样的

这里的{1}就被code1代替了，{2}就被“3”代替

然后我们还需要secretId, secretKey，在腾讯云的密钥管理那里拿，然后copy到etcd到yaml文件下，就是上面一节中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MXGgvVip-1682644996846)(/Users/liuxian/Pictures/typora图片/image-20230428084246948.png)]

validate校验参数

在utils包下新建validate.go，我这里参考golang中使用validator进行数据校验及自定义翻译器_go语言validator自定义验证信息_秋叶原の黑猫的博客-CSDN博客做了一些封装，因为博主使用的gin

package utils

import (
	"context"
	"errors"
	"fmt"
	"github.com/go-playground/locales/en"
	"github.com/go-playground/locales/zh"
	ut "github.com/go-playground/universal-translator"
	"github.com/go-playground/validator/v10"
	enTranslations "github.com/go-playground/validator/v10/translations/en"
	zhTranslations "github.com/go-playground/validator/v10/translations/zh"
	"reflect"
	"regexp"
	"strings"
)

const (
	ValidatorKey  = "ValidatorKey"
	TranslatorKey = "TranslatorKey"
	locale        = "chinese"
)

func TransInit(ctx context.Context) context.Context {
	//设置支持语言
	chinese := zh.New()
	english := en.New()
	//设置国际化翻译器
	uni := ut.New(chinese, chinese, english)
	//设置验证器
	val := validator.New()
	//根据参数取翻译器实例
	trans, _ := uni.GetTranslator(locale)
	//翻译器注册到validator
	switch locale {
	case "chinese":
		zhTranslations.RegisterDefaultTranslations(val, trans)
		//使用fld.Tag.Get("comment")注册一个获取tag的自定义方法
		val.RegisterTagNameFunc(func(fld reflect.StructField) string {
			return fld.Tag.Get("comment")
		})
		val.RegisterValidation("phone", func(fl validator.FieldLevel) bool {
			phone := fl.Field().String()
			//使用正则表达式验证手机号码
			pattern := `^1[3456789]\d{9}$`
			matched, _ := regexp.MatchString(pattern, phone)
			return matched
		})
    // 在TransInit函数中添加电话号码翻译信息
		zhTranslations.RegisterDefaultTranslations(val, trans)
		val.RegisterTranslation("phone", trans, func(ut ut.Translator) error {
			return ut.Add("phone", "{0}格式不正确，必须为手机号码", true)
		}, func(ut ut.Translator, fe validator.FieldError) string {
			t, _ := ut.T("phone", fe.Field())
			return t
		})

	case "english":
		enTranslations.RegisterDefaultTranslations(val, trans)
		val.RegisterTagNameFunc(func(fld reflect.StructField) string {
			return fld.Tag.Get("en_comment")
		})
	}
	ctx = context.WithValue(ctx, ValidatorKey, val)
	ctx = context.WithValue(ctx, TranslatorKey, trans)
	return ctx
}

func DefaultGetValidParams(ctx context.Context, params interface{}) error {
	ctx = TransInit(ctx)
	err := validate(ctx, params)
	if err != nil {
		return err
	}
	return nil
}

func validate(ctx context.Context, params interface{}) error {
	//获取验证器
	val, ok := ctx.Value(ValidatorKey).(*validator.Validate)
	if !ok {
		return errors.New("Validator not found in context")
	}

	//获取翻译器
	tran, ok := ctx.Value(TranslatorKey).(ut.Translator)
	fmt.Println(val, tran)
	if !ok {
		return errors.New("Translator not found in context")
	}
	err := val.Struct(params)
	//如果数据效验不通过，则将所有err以切片形式输出
	if err != nil {
		errs := err.(validator.ValidationErrors)
		sliceErrs := []string{}
		for _, e := range errs {
			//使用validator.ValidationErrors类型里的Translate方法进行翻译
			sliceErrs = append(sliceErrs, e.Translate(tran))
		}
		return errors.New(strings.Join(sliceErrs, ","))
	}
	return nil
}

如果后续想加入自定义的校验，可以参考phone的校验

md5加密

在utils包下建md5.go

package utils

import (
	"crypto/md5"
	"crypto/rand"
	"encoding/hex"
	"math/big"
)

func GeneratePassword(length int) string {
	// 定义密码包含的字符集
	charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789~!@#$%^&*()_+`-={}|[]\\:\";'<>,.?/"

	// 定义密码长度
	// 这里可以根据实际需求进行调整
	passwordLength := length

	// 初始化密码切片
	password := make([]byte, passwordLength)

	// 生成随机密码
	for i := 0; i < passwordLength; i++ {
		charIndex, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
		if err != nil {
			panic(err)
		}
		password[i] = charset[charIndex.Int64()]
	}

	return string(password)
}

// md5加密
func Md5(pasaword string) string {
	hash := md5.New()
	hash.Write([]byte(pasaword))
	passwordHash := hash.Sum(nil)
	// 将密码转换为16进制储存
	passwordHash16 := hex.EncodeToString(passwordHash)
	return passwordHash16
}

// 加盐值加密
func Md5Password(password, salt string) string {
	return Md5(password + salt)
}

// 解密
func ValidMd5Password(password, salt, dataPwd string) bool {
	return Md5Password(password, salt) == dataPwd
}

我这里做了个加盐处理，减少被破译的可能性，在业务部分直接调Md5Password()输入密码和盐值就可以了

，然后还做了个随机密码，因为用户在手机验证码登陆的时候，要给密码一个随机值

总结

这一章我们引入了gorm、redis、腾讯云SMS短信服务、validate校验参数、md5加密和解密、日志输入到kafka，下一章我们将完成api的编写。

感谢

如果你觉得我的文章对你有帮忙，欢迎点赞，关注，star!有问题可以在评论区直接提出来，感谢大家的阅读！🥰🥰🥰🥰🥰🥰

参考

logx | go-zero
golang中使用validator进行数据校验及自定义翻译器_go语言validator自定义验证信息_秋叶原の黑猫的博客-CSDN博客