lian-go.git

README

gitee.com/copylian/lian-go.git

运行环境

• 开发语言: go1.18+
• 开发框架: gin
• RPC框架: grpc
• 数据库: mysql, redis
• 消息队列: -
• 代码管理工具：-

gitee

地址

https://gitee.com/copylian/lian-go.git

分支说明

• master：正式环境
• bvt：预发环境, 正式环境数据库一致, 预发环境测试通过后才可以发布线上环境
• test：测试环境, 主要提供给测试使用
• local：本地环境, 主要提供给开发使用

目录结构

.
├── Dockerfile   
├── Jenkinsfile
├── LICENSE
├── README.md
├── app                 # 应用代码
│   ├── cache             # 缓存
│   ├── constant          # 常量定义
│   ├── error             # 错误定义
│   ├── entity            # 各种结构体定义
│   ├── grpc              # 提供GRPC服务
│   ├── http              # 提供HTTP服务
│   ├── logic             # 逻辑层
│   ├── model             # 数据模型层，数据表实体类
│   └── service           # 服务层
│   └── validate          # 验证层
├── bootstrap             # 框架服务启动
│   ├── app.go
│   ├── config.go
│   ├── database.go
│   └── redis.go 
├── config              # 各个环境配置
│   ├── bvt             # 预发布
│   ├── local           # 本地
│   ├── prod            # 正式
│   └── test            # 测试
├── go-build.sh         # 用于ci构建
├── go.mod
├── go.sum
├── helper              # 常用类库封装
│   ├── config
│   ├── env
│   ├── errors
│   ├── logger
│   └── strings
├── http-server.go      # 入口文件     
└── routes              # 路由文件夹
    ├── base.go
    ├── user.go
    └── other.go    
    

本地环境配置

1. 拉取代码

   git clone git@gitee.com:copylian/lian-go.git
   

2. 启动

   go run http-server.go -e=local # 本地可以省略local
   

git-子模块

• 无

gitlab地址

• 无

使用说明

顺序流程图

新模块路由配置:

1. routes目录中新建: 新路由名(例如:user.go)

package router

import (
	c "goHelpers/app/http/controller/user"
	"goHelpers/app/http/middleware"

	"github.com/gin-gonic/gin"
)

// RegisterUser 用户路由
func RegisterUser(r *gin.Engine) {

	// 路由组
	g := r.Group("/v1/user")
	{
		// 注册
		g.POST("/register", func(ctx *gin.Context) {
			// 实例化控制器
			c.NewController(ctx).Register()
		})

		// 登录
		g.POST("/login", func(ctx *gin.Context) {
			// 实例化控制器
			c.NewController(ctx).Login()
		})

		// 获取验证码
		g.GET("/get_captcha", func(ctx *gin.Context) {
			// 实例化控制器
			c.NewController(ctx).GetCaptcha()
		})
	}

	// 路由组
	gAuth := r.Group("/v1/user").Use(middleware.ParseUserWithErr())
	{
		// 获取信息
		gAuth.GET("/info", func(ctx *gin.Context) {
			// 实例化控制器
			c.NewController(ctx).Info()
		})

		// 获取列表
		gAuth.GET("/list", func(ctx *gin.Context) {
			// 实例化控制器
			c.NewController(ctx).List()
		})
	}
}

1. 控制器(app/http/controller/user)

// 用户
package user

import (
	"goHelpers/app/entity"
	"goHelpers/app/http/controller"
	logic "goHelpers/app/logic/user"
	"goHelpers/app/validate"

	"github.com/gin-gonic/gin"
)

// userController 控制器结构体
type userController struct {
	controller.BaseController
}

// NewController 实例化结构体控制器
func NewController(ctx *gin.Context) *userController {
	return &userController{controller.NewBaseController(ctx)}
}

// Register 注册
func (c *userController) Register() {
	// 获取参数
	userInfo := &entity.User{}
	c.ShouldBindJSON(userInfo)

	// 验证
	err := validate.User(userInfo)
	if err != nil {
		c.Fail(err.Code(), err.Message(), nil)
		return
	}

	// 处理逻辑
	l := logic.NewLogic(c.GCtx)

	// 注册
	affectedRows, err := l.Register(userInfo)
	if err != nil {
		c.Fail(err.Code(), err.Message(), nil)
		return
	}

	// 返回数据
	rdata := map[string]interface{}{
		"affectedRows": affectedRows,
	}

	// 返回
	c.Success(rdata, "")
}

1. 逻辑层(app/http/logic/user)

package user

import (
	"context"
	"goHelpers/app/entity"
	myErr "goHelpers/app/error"
	errMsg "goHelpers/app/error/user"
	model "goHelpers/app/model/user"
	service "goHelpers/app/service/user"

	stringsHelper "gitee.com/copylian/lian-go.git/helper/strings"
)

// userLogic 逻辑结构体
type userLogic struct {
	Ctx context.Context
}

// NewLogic 实例化结构体逻辑层
func NewLogic(ctx context.Context) *userLogic {
	return &userLogic{Ctx: ctx}
}

// Register 注册
func (l *userLogic) Register(req *entity.User) (affectedRows uint32, rErr myErr.Error) {
	// 错误
	err := myErr.NewError("user")

	// 实例化服务层
	s := service.NewService(l.Ctx)

	// 验证数据
	userInfo := s.GetInfoByUserName(req.Username)
	if userInfo.Id > 0 {
		err.SetCodeMsg(errMsg.UserExists)
		return 0, err
	}

	// 实例化模型
	m := model.NewModel(l.Ctx)

	// 注册
	// 处理密码
	req.Salt = stringsHelper.GetRand(6)
	req.Password = stringsHelper.CreatePassword(req.Password, req.Salt)
	affectedRows = m.Register(req)

	// 返回
	return affectedRows, nil
}

1. 服务层(app/http/service/user)

package user

import (
	"context"
	"goHelpers/app/entity"
	model "goHelpers/app/model/user"
)

// userService 服务结构体
type userService struct {
	Ctx context.Context
}

// NewService 实例化结构体服务层
func NewService(ctx context.Context) *userService {
	return &userService{Ctx: ctx}
}

// GetInfoByUserName 通过用户名查询信息
func (s *userService) GetInfoByUserName(username string) (rdata *entity.User) {
	// 实例化模型
	m := model.NewModel(s.Ctx)

	// 获取数据
	return m.GetInfoByUserName(username)
}

1. 模型车层(app/http/model/user)

package user

import (
	"context"
	"goHelpers/app/entity"
	"goHelpers/app/model"
	"goHelpers/helper/config"

	"gorm.io/gorm"
)

// userModel 模型结构体
type userModel struct {
	Ctx context.Context
	db  *gorm.DB
}

// NewModel 实例化模型结构体
func NewModel(ctx context.Context) *userModel {
	// 获取数据库名称
	dbName, _ := config.GetConfigByName("app.db.dbName").(string)
	return &userModel{ctx, model.NewDB(ctx, dbName).DB}
}

// table 表名称
func (m *userModel) table() string {
	return "user"
}

// GetInfoByUserName 通过用户名查询信息
func (m *userModel) GetInfoByUserName(username string) (rdata *entity.User) {

	// 查询
	err := m.db.Table(m.table()).Where("username = ?", username).Find(&rdata).Error
	if err != nil {
		model.CheckMysqlError(err)
	}
	return
}

// Register 注册
func (m *userModel) Register(req *entity.User) (affectedRows uint32) {

	// 数据

	// 写入
	res := m.db.Table(m.table()).Where("username = ?", req.Username).Create(&req)
	if res.Error != nil {
		model.CheckMysqlError(res.Error)
	}
	return uint32(res.RowsAffected)
}

1. 验证层(app/http/validate/user)

package validate

import (
	"goHelpers/app/entity"
	myErr "goHelpers/app/error"
	errMsg "goHelpers/app/error/user"
)

// User 验证用户
func User(v *entity.User) myErr.Error {
	// 加载错误
	err := myErr.NewError("user")

	// 验证
	if len(v.Username) == 0 {
		// 设置错误
		err.SetCodeMsg(errMsg.UserNameErr)
		return err
	}
	if len(v.Password) == 0 {
		// 设置错误
		err.SetCodeMsg(errMsg.PasswordErr)
		return err
	}
	return nil
}

相关文档

• gin框架
• grpc文档
• git子模块文档