update

Author: LinkinStars

README.md

@@ -12,9 +12,17 @@
 - swagger
 - 
 
+## 项目说明
+
+## 日志说明
+controller 如果出现异常则直接返回相关请求错误，不进行日志打印
+service 如果出现非
+dao出现异常，封装daoerr并返回，不进行打印，统一处理 
+
+
 
 info日志和sql日志分离，这样可以用于后续的监控或者是数据展示，可以用于数据分析等
-stack日志优化打印，其实已经可以了但是还是想要更加完善yidai9n
+stack日志优化打印，其实已经可以了但是还是想要更加完善
 
 将分页逻辑抽离出去，不要和整个模板混在一起
 我们可以弄个什么适配器什么的，搞个分页器，这样只要传递条件就可以了，然后会默认的去走分页的逻辑 

src/base/httper/http_handle.go

@@ -1,68 +1,68 @@
 package httper
 
 import (
-"fmt"
 "net/http"
 
 "github.com/gin-gonic/gin"
-"github.com/pkg/errors"
 
 "base/logger"
+"base/mistake"
 "base/validator"
 )
 
-// 统一处理异常，统一处理日志，统一处理返回
-func HandleResponse(c *gin.Context, err error, data interface{}) {
-// 如果没有错误，就是正常请求
-if err == nil {
-SendResponseSuccess(c, "操作成功", data)
-return
-}
-
-// 针对不同的错误类型进行处理
-switch errors.Cause(err).(type) {
-default:
-logStackInfo(err)
-SendResponseFail(c, http.StatusBadRequest, err.Error())
-}
-
-return
-}
-
 // 绑定参数并验证参数
 // true: 确实存在问题，会返回400错误
 // false: 不存在问题，验证通过
 func BindAndCheck(ctx *gin.Context, data interface{}) bool {
 // 参数映射
 if err := ctx.Bind(data); err != nil {
-HandleResponse(ctx, err, nil)
+HandleResponse(ctx, mistake.NewReqErr("请求参数绑定异常"), nil)
 return true
 }
 
 // 验证参数
 if err := validator.GlobalValidate.Check(data); err != nil {
-HandleResponse(ctx, err, nil)
+HandleResponse(ctx, mistake.NewReqErr(err.Error()), nil)
 return true
 }
 
 return false
 }
 
-// 堆栈信息接口用于内部转换使用
-type stackTracer interface {
-StackTrace() errors.StackTrace
-}
+// 统一处理异常，统一处理日志，统一处理返回
+func HandleResponse(c *gin.Context, err error, data interface{}) {
+// 如果没有错误，就是正常请求
+if err == nil {
+SendResponseSuccess(c, "操作成功", data)
+return
+}
 
-// 判断如果包含堆栈信息的封装就打印出相关堆栈信息，如果没有封装就打印原本错误信息
-func logStackInfo(err error) {
-if e, ok := err.(stackTracer); ok {
-stacks := e.StackTrace()
-var stackEntries []string
-for _, v := range stacks {
-stackEntries = append(stackEntries, fmt.Sprintf("%+v", v))
+// 针对不同的错误类型进行处理
+switch err.(type) {
+// 如果是请求参数异常，返回 400 直接返回err的错误信息
+case *mistake.ReqErr:
+SendResponseFail(c, http.StatusBadRequest, err.Error())
+
+// 服务异常错误，返回 400 返回err的错误message信息，并打印日志记录
+case *mistake.ServiceErr:
+e := err.(*mistake.ServiceErr)
+if e.Err == nil {
+logger.Error(e.Message, "\n", e.Stack)
+} else {
+logger.Error(e.Message, "\n", e.Err, "\n", e.Stack)
 }
-logger.Error(stackEntries)
-} else {
-logger.Error(err)
+SendResponseFail(c, http.StatusBadRequest, e.Message)
+
+// 数据层异常，返回 400 打印错误日志记录，这个错误信息不能返回到前端
+case *mistake.DaoErr:
+e := err.(*mistake.DaoErr)
+logger.Error(e.Err, "\n", e.Stack)
+SendResponseFail(c, http.StatusBadRequest, "数据异常")
+
+// 未知错误，返回 500，证明此错误没有进行包装，直接被返回
+default:
+logger.Error(err, logger.LogStack(0, 0))
+SendResponseFail(c, http.StatusInternalServerError, "服务器端异常")
 }
+return
 }

src/base/logger/zap_impl.go

@@ -1,6 +1,10 @@
 package logger
 
 import (
+"bytes"
+"fmt"
+"runtime"
+"strings"
 "time"
 
 "go.uber.org/zap"
@@ -12,7 +16,7 @@ var myLogger *ZapLogger
 var levelMapping = levelMap()
 
 // 初始化日志框架
-func InitLogger(projectName, logPath string, maxAge, rotationTime time.Duration, level string) {
+func InitLogger(projectName, level, logPath string, maxAge, rotationTime time.Duration) {
 zaplog.InitZap(projectName, logPath, maxAge, rotationTime)
 // 设置打印堆栈深度，设置日志级别
 myLogger = &ZapLogger{
@@ -119,3 +123,26 @@ func (z *ZapLogger) Level() LogLevel {
 func (z *ZapLogger) SetLevel(l LogLevel) {
 z.level = l
 }
+
+// 返回当前调用堆栈信息
+// start 起始调用栈层级
+// end 结束调用栈层级 输入0则会添加调用栈信息直到没有
+func LogStack(start, end int) string {
+stack := bytes.Buffer{}
+for i := start; i < end || end == 0; i++ {
+pc, str, line, _ := runtime.Caller(i)
+if line == 0 {
+break
+}
+
+// 根据项目名称截短输出路径
+projectName := zaplog.YourProjectName
+index := strings.Index(str, projectName)
+if index != -1 {
+index = index + len(projectName) + 1
+str = str[index:]
+}
+stack.WriteString(fmt.Sprintf("%s:%d %s\n", str, line, runtime.FuncForPC(pc).Name()))
+}
+return stack.String()
+}

src/base/logger/zaplog/zap_log.go

@@ -13,15 +13,15 @@ import (
 "go.uber.org/zap/zapcore"
 )
 
-var yourProjectName = "golang-web-template"
+var YourProjectName = "golang-web-template"
 
 // projectName: 项目名称
 // logPath: 日志打印目录
 // maxAge: 日志最大存在时间，单位：天
 // rotationTime: 日志切分时间，单位：小时
 func InitZap(projectName, logPath string, maxAge, rotationTime time.Duration) {
 if len(projectName) != 0 {
-yourProjectName = projectName
+YourProjectName = projectName
 }
 
 maxAge = maxAge * 24 * time.Hour
@@ -101,11 +101,11 @@ func InitZap(projectName, logPath string, maxAge, rotationTime time.Duration) {
 // 自定义打印路径，减少输出日志打印路径长度，根据输入项目名进行减少
 func customCallerEncoder(caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
 str := caller.String()
-index := strings.Index(str, yourProjectName)
+index := strings.Index(str, YourProjectName)
 if index == -1 {
 enc.AppendString(caller.FullPath())
 } else {
-index = index + len(yourProjectName) + 1
+index = index + len(YourProjectName) + 1
 enc.AppendString(str[index:])
 }
 }

src/base/mistake/common_err.go

@@ -1 +1,54 @@
 package mistake
+
+import (
+"base/logger"
+)
+
+// 请求参数异常
+type ReqErr struct {
+Message string
+}
+
+func (e *ReqErr) Error() string {
+return e.Message
+}
+
+func NewReqErr(message string) *ReqErr {
+return &ReqErr{Message: message}
+}
+
+// 业务服务异常
+type ServiceErr struct {
+Message string
+Err error
+Stack string
+}
+
+func (e *ServiceErr) Error() string {
+return e.Message
+}
+
+func NewServiceErr(err error, message string) *ServiceErr {
+return &ServiceErr{
+Message: message,
+Err: err,
+Stack: logger.LogStack(2, 5),
+}
+}
+
+// 数据层异常
+type DaoErr struct {
+Err error
+Stack string
+}
+
+func (e *DaoErr) Error() string {
+return e.Err.Error()
+}
+
+func NewDaoErr(err error) *DaoErr {
+return &DaoErr{
+Err: err,
+Stack: logger.LogStack(2, 5),
+}
+}

src/base/pager/pagination.go

@@ -1,44 +1,43 @@
 package pager
 
 import (
-"errors"
 "reflect"
 )
 
 // 分页模型
 type PageModel struct {
-Page  int `json:"page"`
+PageNum int `json:"page_num"`
 PageSize int `json:"page_size"`
 TotalPages int64 `json:"total_pages"`
 TotalRecords int64 `json:"total_records"`
 Records interface{} `json:"records"`
 }
 
 // 构造分页对象
-// page: 当前页码
+// pageNum: 当前页码，从1开始
 // pageSize: 每页条数
 // totalRecords: 总条数
 // records: 分页数据，必须为slice，不能为nil或者其他对象，可以是空的slice
-func NewPageModel(page, pageSize int, totalRecords int64, records interface{}) *PageModel {
+func NewPageModel(pageNum, pageSize int, totalRecords int64, records interface{}) *PageModel {
 sliceValue := reflect.Indirect(reflect.ValueOf(records))
 if sliceValue.Kind() != reflect.Slice {
 panic("分页异常，需要传入一个slice类型")
 }
-
-if page <= 0 {
-page = 1
-}
 if pageSize <= 0 {
-pageSize = 10
+panic("分页异常，每页条数必须为正数")
+}
+
+if pageNum <= 0 {
+pageNum = 1
 }
 if totalRecords < 0 {
 totalRecords = 0
 }
 
-totalPages, _ := calcTotalPages(int64(pageSize), totalRecords)
+totalPages := calcTotalPages(int64(pageSize), totalRecords)
 
 return &PageModel{
-Page:  page,
+PageNum: pageNum,
 PageSize: pageSize,
 TotalPages: totalPages,
 TotalRecords: totalRecords,
@@ -47,23 +46,15 @@ func NewPageModel(page, pageSize int, totalRecords int64, records interface{}) *
 }
 
 // 计算页码逻辑
-func calcTotalPages(pageSize, totalRecords int64) (totalPages int64, err error) {
-if pageSize <= 0 {
-return 0, errors.New("page size should be positive integer")
-}
-
-if totalRecords < 0 {
-return 0, errors.New("total records should not be negative integer")
-}
-
+func calcTotalPages(pageSize, totalRecords int64) (totalPages int64) {
 if totalRecords == 0 {
-return 0, nil
+return 0
 }
 
 if totalRecords%pageSize == 0 {
 totalPages = totalRecords / pageSize
 } else {
 totalPages = totalRecords/pageSize + 1
 }
-return totalPages, nil
+return totalPages
 }

src/base/validator/validator.go

@@ -58,10 +58,10 @@ func (m *MyValidator) Check(value interface{}) error {
 // 将所有的参数错误进行翻译然后拼装成字符串返回
 errBuf := bytes.Buffer{}
 for i := 0; i < len(errs); i++ {
-errBuf.WriteString(errs[i].Translate(m.Trans) + "\n ")
+errBuf.WriteString(errs[i].Translate(m.Trans) + " \n")
 }
 
-// 删除掉最后一个换行符和空格
+// 删除掉最后一个空格和换行符
 errStr := errBuf.String()
 return errors.New(errStr[:len(errStr)-2])
 }

src/controller/user_controller.go

@@ -65,8 +65,8 @@ func UpdateUser(ctx *gin.Context) {
 httper.HandleResponse(ctx, err, nil)
 }
 
-// @Summary 查询用户
-// @Description 查询用户
+// @Summary 根据id查询用户
+// @Description 根据id查询用户
 // @Tags User
 // @Accept json
 // @Produce json
@@ -79,6 +79,25 @@ func GetUser(ctx *gin.Context) {
 httper.HandleResponse(ctx, errors.New("参数错误"), nil)
 return
 }
+
 u, err := service.GetUser(id)
 httper.HandleResponse(ctx, err, u)
 }
+
+// @Summary 分页查询用户
+// @Description 分页查询用户
+// @Tags User
+// @Accept json
+// @Produce json
+// @Param data body val.UpdateUserReq true "分页用户条件信息"
+// @Success 200 {object} val.GetUsersReq
+// @Router /users [get]
+func ListUser(ctx *gin.Context) {
+getUsersReq := &val.GetUsersReq{}
+if httper.BindAndCheck(ctx, getUsersReq) {
+return
+}
+
+pageModel, err := service.ListUser(getUsersReq)
+httper.HandleResponse(ctx, err, pageModel)
+}