Gin框架--项目基本环境搭建
创建项目
main.go 文件为整个项目的入口，gin框架的初始化和启动等我都放在这了
app/consts：该层存放常量的定义文件
app/controllers：该层存放控制层的文件
app/model：该层存放实体类文件，以及数据库的初始化文件，我将所有对数据库的操作方法都放在其独自的实体类中
app/router：该层存放所有的路由，经过路由可以跳转到controller层
app/services：该层为业务层（接口类），所有的业务逻辑都写在这一层类中
app/utils：该层为自己写的工具类方法
configure：配置文件放在这里
database：sqlite3的数据库
目前就只添加这些文件夹，后续有其它需求可根据个人自行添加。
第三方包下载
go get github.com/gin-gonic/gin // gin框架
go get go.uber.org/zap // zap日志库
go get github.com/gin-contrib/zap // gin中使用zap日志系统
go get github.com/natefinch/lumberjack // zap日志轮转与归档包
go get -u github.com/jinzhu/gorm // gorm
go get gopkg.in/ini.v1 // ini文件读取包
// 项目中如果没有用到sqlite3可以不安装以下包
go get github.com/gogf/gf/os/gfile // 文件判断
go get github.com/mattn/go-sqlite3 // sqlite3驱动
日志配置
logger/logger.go
package logger
import (
"github.com/gin-gonic/gin"
"github.com/natefinch/lumberjack"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
"net"
"net/http/httputil"
"os"
"runtime/debug"
"strings"
"time"
)
// 1 定义一下logger使用的常量
const (
mode = "dev" //开发模式
filename = "web_app.log" // 日志存放路径
//level = "debug" // 日志级别
level = zapcore.DebugLevel // 日志级别
max_size = 200 //最大存储大小
max_age = 30 //最大存储时间
max_backups = 7 //#备份数量
)
// 2 初始化Logger对象
func InitLogger() (err error) {
// 创建Core三大件，进行初始化
writeSyncer := getLogWriter(filename, max_size, max_backups, max_age)
encoder := getEncoder()
// 创建核心-->如果是dev模式，就在控制台和文件都打印，否则就只写到文件中
var core zapcore.Core
if mode == "dev" {
// 开发模式，日志输出到终端
consoleEncoder := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())
// NewTee创建一个核心，将日志条目复制到两个或多个底层核心中。
core = zapcore.NewTee(
zapcore.NewCore(encoder, writeSyncer, level),
zapcore.NewCore(consoleEncoder, zapcore.Lock(os.Stdout), level),
)
} else {
core = zapcore.NewCore(encoder, writeSyncer, level)
}
//core := zapcore.NewCore(encoder, writeSyncer, level)
// 创建 logger 对象
log := zap.New(core, zap.AddCaller())
// 替换全局的 logger, 后续在其他包中只需使用zap.L()调用即可
zap.ReplaceGlobals(log)
return
}
// 获取Encoder，给初始化logger使用的
func getEncoder() zapcore.Encoder {
// 使用zap提供的 NewProductionEncoderConfig
encoderConfig := zap.NewProductionEncoderConfig()
// 设置时间格式
encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
// 时间的key
encoderConfig.TimeKey = "time"
// 级别
encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
// 显示调用者信息
encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
// 返回json 格式的 日志编辑器
return zapcore.NewJSONEncoder(encoderConfig)
}
// 获取切割的问题，给初始化logger使用的
func getLogWriter(filename string, maxSize, maxBackup, maxAge int) zapcore.WriteSyncer {
// 使用 lumberjack 归档切片日志
lumberJackLogger := &lumberjack.Logger{
Filename: filename,
MaxSize: maxSize,
MaxBackups: maxBackup,
MaxAge: maxAge,
}
return zapcore.AddSync(lumberJackLogger)
}
// GinLogger 用于替换gin框架的Logger中间件，不传参数，直接这样写
func GinLogger(c *gin.Context) {
logger := zap.L()
start := time.Now()
path := c.Request.URL.Path
query := c.Request.URL.RawQuery
c.Next() // 执行视图函数
// 视图函数执行完成，统计时间，记录日志
cost := time.Since(start)
logger.Info(path,
zap.Int("status", c.Writer.Status()),
zap.String("method", c.Request.Method),
zap.String("path", path),
zap.String("query", query),
zap.String("ip", c.ClientIP()),
zap.String("user-agent", c.Request.UserAgent()),
zap.String("errors", c.Errors.ByType(gin.ErrorTypePrivate).String()),
zap.Duration("cost", cost),
)
}
// GinRecovery 用于替换gin框架的Recovery中间件，因为传入参数，再包一层
func GinRecovery(stack bool) gin.HandlerFunc {
logger := zap.L()
return func(c *gin.Context) {
defer func() {
// defer 延迟调用，出了异常，处理并恢复异常，记录日志
if err := recover(); err != nil {
// 这个不必须，检查是否存在断开的连接(broken pipe或者connection reset by peer)---------开始--------
var brokenPipe bool
if ne, ok := err.(*net.OpError); ok {
if se, ok := ne.Err.(*os.SyscallError); ok {
if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
brokenPipe = true
}
}
}
//httputil包预先准备好的DumpRequest方法
httpRequest, _ := httputil.DumpRequest(c.Request, false)
if brokenPipe {
logger.Error(c.Request.URL.Path,
zap.Any("error", err),
zap.String("request", string(httpRequest)),
)
// 如果连接已断开，我们无法向其写入状态
c.Error(err.(error))
c.Abort()
return
}
// 这个不必须，检查是否存在断开的连接(broken pipe或者connection reset by peer)---------结束--------
// 是否打印堆栈信息，使用的是debug.Stack()，传入false，在日志中就没有堆栈信息
if stack {
logger.Error("[Recovery from panic]",
zap.Any("error", err),
zap.String("request", string(httpRequest)),
zap.String("stack", string(debug.Stack())),
)
} else {
logger.Error("[Recovery from panic]",
zap.Any("error", err),
zap.String("request", string(httpRequest)),
)
}
// 有错误，直接返回给前端错误，前端直接报错
//c.AbortWithStatus(http.StatusInternalServerError)
// 该方式前端不报错
c.String(200, "访问出错了")
}
}()
c.Next()
}
}
router的初始化
routers/routers_init.go
package routers
import (
"chat/logger"
"github.com/gin-gonic/gin"
)
type Option func(e *gin.Engine)
var options = []Option{}
func Include(opts ...Option) {
options = append(options, opts...)
}
func InitRouters() *gin.Engine {
logger.InitLogger()
r := gin.New()
for _, opt := range options {
opt(r)
}
return r
}
每个app下创建appName_routers.go
package auth
import (
"chat/app/auth/handler"
"github.com/gin-gonic/gin"
)
func Routers(e *gin.Engine) {
// 登录
e.GET("/login", handler.LoginHandler)
e.POST("/login", handler.LoginHandler)
// 注册
e.GET("/register", handler.RegisterHandler)
e.POST("/register", handler.RegisterHandler)
}
数据库配置文件初始化
config/my.ini
appname = "gin框架测试"
httpport = 9898
#开启JSON请求
copyrequestbody = true
#数据库类型：mysql/sqlite3
db_type = "mysql"
[mysql]
db_alias = "default"
db_name = "gin_test"
db_user = "root"
db_pwd = "root"
db_host = "127.0.0.1"
db_port = 3306
db_charset = "utf8"
[sqlite3]
db_alias = "default"
db_name = "gin_test.db"
models初始化
models/conns_init.go
package models
import (
"awesomeProject/app/consts"
_ "github.com/go-sql-driver/mysql"
"github.com/gogf/gf/os/gfile"
"github.com/jinzhu/gorm"
_ "github.com/mattn/go-sqlite3"
"gopkg.in/ini.v1"
"log"
"os"
"path"
)
// 在其它model的实体类中可直接调用
var db *gorm.DB
func InitDB(conf *ini.File) *gorm.DB {
var err error
// 数据库的类型
dbType := conf.Section("").Key("db_type").String()
// Mysql配置信息
mysqlName := conf.Section("mysql").Key("db_name").String()
mysqlUser := conf.Section("mysql").Key("db_user").String()
mysqlPwd := conf.Section("mysql").Key("db_pwd").String()
mysqlHost := conf.Section("mysql").Key("db_host").String()
mysqlPort := conf.Section("mysql").Key("db_port").String()
mysqlCharset := conf.Section("mysql").Key("db_charset").String()
// sqlite3配置信息
sqliteName := conf.Section("sqlite3").Key("db_name").String()
var dataSource string
switch dbType {
case "mysql":
dataSource = mysqlUser + ":" + mysqlPwd + "@tcp(" + mysqlHost + ":" +
mysqlPort + ")/" + mysqlName + "?charset=" + mysqlCharset + "&" + "parseTime=true"
db, err = gorm.Open(dbType, dataSource)
case "sqlite3":
dataSource = "database" + string(os.PathSeparator) + sqliteName
if !gfile.Exists(dataSource) {
os.MkdirAll(path.Dir(dataSource), os.ModePerm)
os.Create(dataSource)
}
db, err = gorm.Open(dbType, dataSource)
}
if err != nil {
db.Close()
zap.L().Error("数据库连接错误")
}
// 设置连接池，空闲连接
db.DB().SetMaxIdleConns(50)
// 打开链接
db.DB().SetMaxOpenConns(100)
// 表明禁用后缀加s
db.SingularTable(true)
return db
}
models/modelFunctions.go
package models
import (
"awesomeProject/app/consts"
"log"
)
type User struct {
ID int `gorm:"column:id; parimary_key", json:"id"`
Name string `gorm:"column:name" json:"name"` // 用户名
Accounts string `gorm:"column:accounts" json:"accounts"` // 帐号
PassWord string `gorm:"column:password" json:"password"` // 密码
}
func FindAllUser() {
}
func AddUser(user *User) error {
if err := db.Create(user).Error; err != nil {
log.Fatal(err)
return consts.ADD_DATA_ERROR
}
return nil
}
main.go
package main
import (
"chat/app/auth"
"chat/app/chat"
"chat/app/home"
"gopkg.in/ini.v1"
"chat/logger"
routers2 "chat/routers"
)
func main() {
// 读取配置文件
conf, err := ini.Load("./config/my.ini")
if err != nil {
log.Fatal("配置文件读取失败, err = ", err)
}
// 注册logger
logger.InitLogger()
r.Use(logger.GinLogger, logger.GinRecovery(true))
// 注册路由
routers2.Include(chat.Routers, home.Routers, auth.Routers)
r := routers2.InitRouters()
// 注册logger
r.Use(logger.GinLogger, logger.GinRecovery(true))
// 加载template文件夹下的所有html映射关系
r.LoadHTMLGlob("./templates/**/*")
// 加载静态文件目录
r.Static("/static", "./static")
// 初始化数据库连接
db := models.InitDB(conf)
db.AutoMigrate(&auth2.UserInfo{}) // 如果需要,则启动自动迁移数据库,在mysql库中创建对应的表结构
defer db.Close()
// 根据配置文件中的配置启动项目
port := ":" + conf.Section("").Key("httpport").String()
if err := r.Run(port); err != nil {
log.Fatal("程序启动失败:", err)
}
// 正常启动项目
if err := r.Run(":8080"); err != nil {
panic(err.Error())
}
}
可能会有朋友会有这么一个疑问，为什么我没有把各种初始化的类文件放在同一个文件夹下进行管理，原因是我在另创的一个文件夹下完成初始化数据库的并返回个一个db，在model包中的实体类调用不到这个包中的db这个库，当通过其它的方式调用尝试
后反而出现一个循环导包的错误，因此在目前我没找到其它方法的情况下我将初始化数据的方法类放在model中，这样model中的实体类可直接调用。（后续找到方法后再来改进，也希望大佬们提出您的宝贵意见）
beego会有所不同，只要在一开始进行了数据库的初始化，那么在代码的其它地方就可以通过orm.NewOrm()直接调用操作数据库。
python防脱发技巧
浙公网安备 33010602011771号