# lian-go

**Repository Path**: copylian/lian-go

## Basic Information

- **Project Name**: lian-go
- **Description**: golang开发框架
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-04-24
- **Last Updated**: 2023-05-01

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Go语言

## README

# gitee.com/copylian/lian-go.git


## 运行环境

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

## gitee

### 地址

[https://gitee.com/copylian/lian-go.git](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. 拉取代码
    ```shell
    git clone git@gitee.com:copylian/lian-go.git
    ```


2. 启动

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

## git-子模块
 - 无

## gitlab地址
- 无


## 使用说明
###  顺序流程图
![输入图片说明](flow.png)


### 新模块路由配置:

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

```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()
		})
	}
}

```

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

```go
// 用户
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, "")
}

```

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

```go
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
}

```

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

```go
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)
}

```

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

```go
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)
}

```

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

```go
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框架](https://github.com/gin-gonic/gin)
- [grpc文档](https://grpc.io/docs/)
- [git子模块文档](https://git-scm.com/book/zh/v1/Git-%E5%B7%A5%E5%85%B7-%E5%AD%90%E6%A8%A1%E5%9D%97)