goi

package module
v1.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 27, 2024 License: BSD-3-Clause Imports: 32 Imported by: 0

README

goi

基于 net/http 进行开发的 Web 框架

goi 创建命令

使用 go env GOMODCACHE 获取 go 软件包路径：mypath\Go\pkg\mod + github.com\!never!stop!dreaming!wang\goi@v版本号\goi\goi.exe

使用 go env GOROOT 获取 go 安装路径 mypath\Go + bin 将可执行文件复制到 Go\bin 目录下

Windows: copy mypath\Go\pkg\mod\github.com\!never!stop!dreaming!wang\goi@v版本号\goi\goi.exe mypath\Go\bin\goi.exe

编译

go build -o goi.exe

Linux: cp mypath\go\pkg\mod\github.com\!never!stop!dreaming!wang\goi@v版本号\goi\goi mypath\go\bin\goi

编译

go build -o goi.exe

> goi

Usage（用法）:                                         
        goi <command> [arguments]                      
The commands are（命令如下）:                          
        create-project  myproject   创建项目       
        create-app      myapp       创建app

示例

# 创建项目
> goi create-project example

# 新建应用 app
> cd example
> goi create-app myapp

路由

多级路由

子父路由，内置路由转换器，自定义路由转换器

  • Router.Include(UrlPath) 创建一个子路由
  • Router.UrlPatterns(UrlPath, goi.AsView{GET: Test1}) 注册一个路由
静态路由

静态路由映射，返回文件对象即响应该文件内容

  • Router.StaticUrlPatterns(UrlPath, StaticUrlPath) 注册一个静态路由

中间件

  • 请求中间件：Server.MiddleWares.BeforeRequest(RequestMiddleWare) 注册请求中间件
  • 视图中间件：Server.MiddleWares.BeforeView(ViewMiddleWare) 注册视图中间件
  • 响应中间件：Server.MiddleWares.BeforeResponse(ResponseMiddleWare) 注册响应中间件

日志模块

  • 支持三种日志
    • 信息日志：Log.INFO_OUT_PATH
    • 访问日志：Log.ACCESS_OUT_PATH
    • 错误日志：Log.ERROR_OUT_PATH ERROR
  • 日志等级：是否开启 Log.DEBUG = true
    • DEBUG
      • 使用：goi.Debug()
      • 输出：Console（终端）、INFO 信息日志、ACCESS 访问日志、ERROR 错误日志
    • INFO
      • 使用：goi.Info()
      • 输出：Console（终端）、INFO 信息日志、ACCESS 访问日志
    • WARNING
      • 使用：goi.Warning()
      • 输出：Console（终端）、INFO 信息日志
    • ERROR
      • 使用：goi.Error()
      • 输出：Console（终端）、INFO 信息日志、ERROR 错误日志
    • MeteLog
      • 使用：goi.MetaLog()
      • 输出：Console（终端）、INFO 信息日志、ACCESS 访问日志、ERROR 错误日志
  • 日志切割：两种可同时设置满足任意一种即切割
    • 按照日志大小：Log.SplitSize
      • 例：Log.SplitSize = 1024 * 1024
    • 按照日期格式：Log.SplitTime = "2006-01-02"
      • 例：Log.SplitTime = "2006-01-02" 设置日期格式

缓存

  • 支持过期策略，默认惰性删除
    • PERIODIC（定期删除：默认每隔 1s 就随机抽取一些设置了过期时间的 key，检查其是否过期）
    • SCHEDULED（定时删除：某个设置了过期时间的 key，到期后立即删除）
  • 支持内存淘汰策略
    • NOEVICTION（直接抛出错误）
    • ALLKEYS_RANDOM（随机删除-所有键）
    • ALLKEYS_LRU（删除最近最少使用-所有键）
    • ALLKEYS_LFU（删除最近最不频繁使用-所有键）
    • VOLATILE_RANDOM（随机删除-设置过期时间的键）
    • VOLATILE_LRU（删除最近最少使用-设置过期时间的键）
    • VOLATILE_LFU（删除最近最不频繁使用-设置过期时间的键）
    • VOLATILE_TTL（删除即将过期的键-设置过期时间的键）

内置 auth 密码生成与验证

func TestAuth(t *testing.T) {
	// 原始密码
	password := "goi123456"

	// 生成密码的哈希值
	hashedPassword, err := MakePassword(password, bcrypt.DefaultCost)
	if err != nil {
		fmt.Println("密码加密失败:", err)
		return
	}

	// 输出加密后的密码
	fmt.Println("加密后的密码:", hashedPassword)

	// 验证密码
	isValid := CheckPassword(password, hashedPassword)
	if isValid {
		fmt.Println("密码验证成功")
	} else {
		fmt.Println("密码验证失败")
	}
}

内置 Converter 路由转换器

注册路由转换器

func init() {
	// 注册路由转换器

	// 手机号
	goi.RegisterConverter("phone", `(1[3456789]\d{9})`)
}

使用

func init() {
	// 创建一个子路由
	testRouter := example.Server.Router.Include("/test", "测试路由")
    {
        // 注册一个路径
        testRouter.UrlPatterns("/test_phone/<phone:phone>", "", goi.AsView{GET: TestPhone}) // 测试路由转换器
    }
}

// 测试手机号路由转换器
func TestPhone(request *goi.Request) interface{} {
	var phone string
	var err error
	err = request.PathParams.Get("phone", &phone)
	if err != nil {
		return goi.Response{
			Status: http.StatusOK,
			Data: goi.Data{
				Status: http.StatusBadRequest,
				Msg:    "参数错误",
				Data:   nil,
			},
		}
	}
	resp := map[string]interface{}{
		"status": http.StatusOK,
		"msg":    phone,
		"data":   "OK",
	}
	return resp
}

内置 Validator 参数验证器

注册参数验证器

func init() {
	// 注册验证器

	// 手机号
	goi.RegisterValidator("phone", phoneValidate)
}

// phone 类型
func phoneValidate(value string) goi.ValidationError {
	var IntRe = `^(1[3456789]\d{9})$`
	re := regexp.MustCompile(IntRe)
	if re.MatchString(value) == false {
		return goi.NewValidationError(fmt.Sprintf("参数错误：%v", value), http.StatusBadRequest)
	}
	return nil
}

使用

// 参数验证
type testParamsValidParams struct {
	Username string            `name:"username" required:"string"`
	Password string            `name:"password" required:"string"`
	Age      string            `name:"age" required:"int"`
	Phone    string            `name:"phone" required:"phone"`
	Args     []string          `name:"args" optional:"slice"`
	Kwargs   map[string]string `name:"kwargs" optional:"map"`
}

// required 必传参数
// optional 可选

func TestParamsValid(request *goi.Request) interface{} {
	var params testParamsValidParams
	var validationErr goi.ValidationError
	validationErr = request.BodyParams.ParseParams(&params)
	if validationErr != nil {
		// 验证器返回
		return validationErr.Response()

		// 自定义返回
		// return goi.Response{
		// 	Status: http.StatusOK,
		// 	Data: goi.Data{
		// 		Status: http.StatusBadRequest,
		// 		Msg:    "参数错误",
		// 		Data:   nil,
		// 	},
		// }
	}
	fmt.Println(params)
	return goi.Response{
		Status: http.StatusOK,
		Data: goi.Data{
			Status: http.StatusOK,
			Msg:    "ok",
			Data:   nil,
		},
	}
}

ORM 模型

支持：MySQL、SQLite3

模型迁移

  • MySQL

    // MySQL
type UserModel struct {
	Id          *int64  `field_name:"id" field_type:"int NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT '用户id'" json:"id"`
	Username    *string `field_name:"username" field_type:"varchar(255) DEFAULT NULL COMMENT '用户名'" json:"username"`
	Password    *string `field_name:"password" field_type:"varchar(255) DEFAULT NULL COMMENT '密码'" json:"password"`
	Create_time *string `field_name:"create_time" field_type:"DATETIME DEFAULT NULL COMMENT '更新时间'" json:"create_time"`
	Update_time *string `field_name:"update_time" field_type:"DATETIME DEFAULT NULL COMMENT '创建时间'" json:"update_time"`
}

// 设置表配置
func (UserModel) ModelSet() *model.MySQLSettings {
	encryptFields := []string{
		"username",
		"password",
	}

	modelSettings := &model.MySQLSettings{
		TABLE_NAME:      "user_tb",            // 设置表名
		ENGINE:          "InnoDB",             // 设置存储引擎，默认: InnoDB
		AUTO_INCREMENT:  2,                    // 设置自增长起始值
		COMMENT:         "用户表",                // 设置表注释
		DEFAULT_CHARSET: "utf8mb4",            // 设置默认字符集，如: utf8mb4
		COLLATE:         "utf8mb4_0900_ai_ci", // 设置校对规则，如 utf8mb4_0900_ai_ci;
		ROW_FORMAT:      "",                   // 设置行的存储格式，如 DYNAMIC, COMPACT, FULL.
		DATA_DIRECTORY:  "",                   // 设置数据存储目录
		INDEX_DIRECTORY: "",                   // 设置索引存储目录
		STORAGE:         "",                   // 设置存储类型，如 DISK、MEMORY、CSV
		CHECKSUM:        0,                    // 表格的校验和算法，如 1 开启校验和
		DELAY_KEY_WRITE: 0,                    // 控制非唯一索引的写延迟，如 1
		MAX_ROWS:        0,                    // 设置最大行数
		MIN_ROWS:        0,                    // 设置最小行数
		PARTITION_BY:    "",                   // 定义分区方式，如 RANGE、HASH、LIST

		// 自定义配置
		MySettings: model.MySettings{
			"encrypt_fields": encryptFields,
		},
	}

	return modelSettings
}

  • SQLite

    // 用户表
type UserSqliteModel struct {
	Id          *int64  `field_name:"id" field_type:"INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT" json:"id"`
	Username    *string `field_name:"username" field_type:"TEXT" json:"username"`
	Password    *string `field_name:"password" field_type:"TEXT" json:"password"`
	Create_time *string `field_name:"create_time" field_type:"TEXT NOT NULL" json:"create_time"`
	Update_time *string `field_name:"update_time" field_type:"TEXT" json:"update_time"`
	Test        *string `field_name:"test_txt" field_type:"TEXT" json:"txt"` // 更新表字段
}

// 设置表配置
func (UserSqliteModel) ModelSet() *model.SQLite3Settings {
	encryptFields := []string{
		"username",
		"password",
	}

	modelSettings := &model.SQLite3Settings{
		TABLE_NAME: "user_tb", // 设置表名

		// 自定义配置
		MySettings: model.MySettings{
			"encrypt_fields": encryptFields,
		},
	}
	return modelSettings
}
查询多条数据
// 参数验证
type testModelListParams struct {
	Page     int `name:"page" required:"int"`
	Pagesize int `name:"pagesize" required:"int"`
}

// 读取多条数据到 Model
func TestModelList(request *goi.Request) interface{} {
	var params testModelListParams
	var validationErr goi.ValidationError
	validationErr = request.BodyParams.ParseParams(&params)
	if validationErr != nil {
		// 验证器返回
		return validationErr.Response()

	}

	mysqlObj, err := db.MySQLConnect("default", "mysql_slave_2")
	defer mysqlObj.Close()
	// SQLite3DB, err := db.SQLite3Connect("sqlite_1")
	// defer SQLite3DB.Close()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}

	// mysql 数据库
	var userSlice []UserModel
	mysqlObj.SetModel(UserModel{}) // 设置操作表
	mysqlObj.Fields("Id", "Username", "Password").Where("id>?", 1).OrderBy("-id")
	total, page_number, err := mysqlObj.Page(params.Page, params.Pagesize)
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	err = mysqlObj.Select(&userSlice)

	// sqlite3 数据库
	// var userSlice []UserSqliteModel
	// SQLite3DB.SetModel(UserSqliteModel{})
	// err = SQLite3DB.Fields("Id", "Username", "Password").Where("id>?", 1).OrderBy("-id")
	// total, page_number, err := SQLite3DB.Page(params.Page, params.Pagesize)
	// if err != nil {
	// 	return goi.Response{
	// 		Status: http.StatusInternalServerError,
	// 		Data:   err.Error(),
	// 	}
	// }
	// err = SQLite3DB.Select(&userSlice)

	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	...
}
查询单条数据
// 参数验证
type testModelRetrieveParams struct {
	User_id int `name:"user_id" required:"int"`
}

// 读取第一条数据到 Model
func TestModelRetrieve(request *goi.Request) interface{} {
	var params testModelRetrieveParams
	var validationErr goi.ValidationError
	validationErr = request.BodyParams.ParseParams(&params)
	if validationErr != nil {
		// 验证器返回
		return validationErr.Response()

	}

	if params.User_id == 0 {
		// 返回 goi.Response
		return goi.Response{
			Status: http.StatusNotFound, // Status 指定响应状态码
			Data:   nil,
		}
	}

	mysqlObj, err := db.MySQLConnect("default", "mysql_slave_2")
	defer mysqlObj.Close()
	// SQLite3DB, err := db.SQLite3Connect("sqlite_1")
	// defer SQLite3DB.Close()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}

	// mysql 数据库
	user := UserModel{}
	mysqlObj.SetModel(UserModel{}) // 设置操作表
	err = mysqlObj.Fields("Id", "Username").Where("id=?", params.User_id).First(&user)

	// sqlite3 数据库
	// user := UserSqliteModel{}
	// SQLite3DB.SetModel(UserSqliteModel{})
	// err = SQLite3DB.Fields("Id", "Username").Where("id=?", params.User_id).First(&user)

	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	...
}
新增一条数据
// 参数验证
type testModelCreateParams struct {
	Username string `name:"username" required:"string"`
	Password string `name:"password" required:"string"`
}

// 添加一条数据到 Model
func TestModelCreate(request *goi.Request) interface{} {
	var params testModelCreateParams
	var validationErr goi.ValidationError
	validationErr = request.BodyParams.ParseParams(&params)
	if validationErr != nil {
		// 验证器返回
		return validationErr.Response()

	}

	mysqlObj, err := db.MySQLConnect("default", "mysql_slave_2")
	defer mysqlObj.Close()
	// SQLite3DB, err := db.SQLite3Connect("sqlite_1")
	// defer SQLite3DB.Close()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	create_time := time.Now().In(goi.Settings.LOCATION).Format("2006-01-02 15:04:05")
	// mysql 数据库
	user := &UserModel{
		Username:    &params.Username,
		Password:    &params.Password,
		Create_time: &create_time,
	}
	mysqlObj.SetModel(UserModel{})
	// result, err := mysqlObj.Insert(user)
	result, err := mysqlObj.Fields("Id", "Password").Insert(user) // 指定插入字段

	// // sqlite3 数据库
	// user := &UserSqliteModel{
	// 	Username:    &params.Username,
	// 	Password:    &params.Password,
	// 	Create_time: &create_time,
	// }
	// SQLite3DB.SetModel(UserSqliteModel{})
	// // result, err := SQLite3DB.Insert(user)
	// result, err := SQLite3DB.Fields("Id", "Password", "Create_time").Insert(user)

	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	id, err := result.LastInsertId()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	fmt.Println("id", id)

	user.Id = &id
	...
}
更新数据
// 参数验证
type testModelUpdateParams struct {
	User_id  int    `name:"user_id" required:"int"`
	Username string `name:"username" optional:"string"`
	Password string `name:"password" optional:"string"`
}

// 修改 Model
func TestModelUpdate(request *goi.Request) interface{} {
	var params testModelUpdateParams
	var validationErr goi.ValidationError
	validationErr = request.BodyParams.ParseParams(&params)
	if validationErr != nil {
		// 验证器返回
		return validationErr.Response()

	}

	if params.User_id == 0 {
		// 返回 goi.Response
		return goi.Response{
			Status: http.StatusNotFound, // Status 指定响应状态码
			Data:   nil,
		}
	}

	mysqlObj, err := db.MySQLConnect("default", "mysql_slave_2")
	defer mysqlObj.Close()
	// SQLite3DB, err := db.SQLite3Connect("sqlite_1")
	// defer SQLite3DB.Close()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	update_time := time.Now().In(goi.Settings.LOCATION).Format("2006-01-02 15:04:05")
	// mysql 数据库
	update_user := &UserModel{
		Username:    nil,
		Password:    nil,
		Update_time: &update_time,
	}
	if params.Username != ""{
		update_user.Username = &params.Username
	}
	if params.Password != ""{
		update_user.Password = &params.Password
	}
	mysqlObj.SetModel(UserModel{})
	// result, err := mysqlObj.Where("id=?", user_id).Update(update_user)
	result, err := mysqlObj.Fields("Username").Where("id=?", params.User_id).Update(update_user) // 更新指定字段

	// sqlite3 数据库
	// update_user := &UserSqliteModel{
	// 	Username:    nil,
	// 	Password:    nil,
	// 	Update_time: &update_time,
	// }
	// if params.Username != ""{
	// 	update_user.Username = &params.Username
	// }
	// if params.Password != ""{
	// 	update_user.Password = &params.Password
	// }
	// SQLite3DB.SetModel(UserSqliteModel{})
	// result, err := SQLite3DB.Where("id=?", params.User_id).Update(update_user)

	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	rowNum, err := result.RowsAffected()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	if rowNum == 0 {
		return goi.Response{
			Status: http.StatusOK,
			Data: goi.Data{
				Status: http.StatusInternalServerError,
				Msg:    "修改失败！",
				Data:   nil,
			},
		}
	}
	fmt.Println("rowNum", rowNum)
    ...
}
删除数据
// 删除 Model
func TestModelDelete(request *goi.Request) interface{} {
	var user_id int
	var err error
	err = request.PathParams.Get("user_id", &user_id)
	if err != nil {
		return goi.Response{
			Status: http.StatusOK,
			Data: goi.Data{
				Status: http.StatusBadRequest,
				Msg:    "参数错误",
				Data:   nil,
			},
		}
	}

	if user_id == 0 {
		// 返回 goi.Response
		return goi.Response{
			Status: http.StatusNotFound, // Status 指定响应状态码
			Data:   nil,
		}
	}

	mysqlObj, err := db.MySQLConnect("default", "mysql_slave_2")
	defer mysqlObj.Close()
	// SQLite3DB, err := db.SQLite3Connect("sqlite_1")
	// defer SQLite3DB.Close()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	// mysql 数据库
	mysqlObj.SetModel(UserModel{})
	result, err := mysqlObj.Where("id=?", user_id).Delete()

	// sqlite3 数据库
	// SQLite3DB.SetModel(UserSqliteModel{})
	// result, err := SQLite3DB.Where("id=?", user_id).Delete()

	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	rowNum, err := result.RowsAffected()
	if err != nil {
		return goi.Response{
			Status: http.StatusInternalServerError,
			Data:   err.Error(),
		}
	}
	if rowNum == 0 {
		return goi.Response{
			Status: http.StatusOK,
			Data: goi.Data{
				Status: http.StatusOK,
				Msg:    "已删除！",
				Data:   nil,
			},
		}
	}
	fmt.Println("rowNum", rowNum)
	...
}

内置 JWT Token

  • 生成 Token
header := map[string]interface{}{
  "alg": "SHA256",
  "typ": "JWT",
}

payloads := map[string]interface{}{
  "user_id":  1,
  "username": "wjh123",
  "exp":      expTime,
}
token, err := jwt.NewJWT(header, payloads, "xxxxxx")
  • 验证 Token
payloads, err := jwt.CkeckToken(token, "xxxxxx")
if jwt.JwtDecodeError(err) { // token 解码错误！
 pass
}else if jwt.JwtExpiredSignatureError(err) { // token 已过期
 pass
}

详细示例：example

Documentation

Index

Constants

View Source 
const (
	LFUInitValue    = 5   // LFU初始化值
	LFULogFactor    = 0.1 // LFU对数增长因子
	MaxCounterValue = 255 // 计数器最大值
)

Variables

View Source 
var Cache *metaCache
View Source 
var Log *metaLog
View Source 
var Settings *metaSettings

Functions

func GenerateECCCertificate added in v1.0.13 

func GenerateECCCertificate(certificateTemplate x509.Certificate, outPath string) error

func GenerateRSACertificate added in v1.0.13 

func GenerateRSACertificate(bits int, certificateTemplate x509.Certificate, outPath string) error

func LFULogIncr 

func LFULogIncr(counter uint8) uint8

计算 LFU 递增值

func RegisterConverter 

func RegisterConverter(name string, converter string)

func RegisterValidator added in v1.3.0 

func RegisterValidator(name string, validate validateFunc)

注册一个验证器

func Version 

func Version() string

版本

Types

type AsView 

type AsView struct {
	GET     HandlerFunc
	HEAD    HandlerFunc
	POST    HandlerFunc
	PUT     HandlerFunc
	PATCH   HandlerFunc
	DELETE  HandlerFunc
	CONNECT HandlerFunc
	OPTIONS HandlerFunc
	TRACE   HandlerFunc
	// contains filtered or unexported fields
}

路由视图

type Data 

type Data struct {
	Status int         `json:"status"`
	Msg    string      `json:"msg"`
	Data   interface{} `json:"data"`
}

内置响应数据格式

type Engine 

type Engine struct {
	Router      *metaRouter
	MiddleWares *metaMiddleWares
	Settings    *metaSettings
	Cache       *metaCache
	Log         *metaLog
	// contains filtered or unexported fields
}

Engine 实现 ServeHTTP 接口

func NewHttpServer 

func NewHttpServer() *Engine

创建一个 Http 服务

func (*Engine) HandlerHTTP 

func (engine *Engine) HandlerHTTP(request *Request, response http.ResponseWriter) (result interface{})

处理 HTTP 请求

func (*Engine) RunServer 

func (engine *Engine) RunServer()

启动 http 服务

func (*Engine) RunTime added in v1.1.0 

func (engine *Engine) RunTime() time.Duration

获取当前运行时间 返回时间间隔

func (*Engine) RunTimeStr added in v1.1.0 

func (engine *Engine) RunTimeStr() string

获取当前运行时间 返回字符串

func (*Engine) ServeHTTP 

func (engine *Engine) ServeHTTP(response http.ResponseWriter, request *http.Request)

实现 ServeHTTP 接口

func (*Engine) StopServer added in v1.1.0 

func (engine *Engine) StopServer() error

停止 http 服务

type EvictPolicy 

type EvictPolicy uint8 // 缓存淘汰策略

const (
	NOEVICTION      EvictPolicy = iota // 直接抛出错误，不淘汰任何已经存在的键
	ALLKEYS_RANDOM                     // 所有的键 随机移除 key
	ALLKEYS_LRU                        // 所有的键 移除最近最少使用的 key
	ALLKEYS_LFU                        // 所有的键 移除最近最不频繁使用的 key
	VOLATILE_RANDOM                    // 所有设置了过期时间的键 随机移除 key
	VOLATILE_LRU                       // 所有设置了过期时间的键 移除最近最少使用的 key
	VOLATILE_LFU                       // 所有设置了过期时间的键 移除最近最不频繁使用的 key
	VOLATILE_TTL                       // 所有设置了过期时间的键 移除快过期的 key
)

缓存淘汰策略

type ExpirationPolicy 

type ExpirationPolicy uint8 // 过期策略

const (
	// 默认惰性删除: 在获取某个 key 的时候，检查这个 key 如果设置了过期时间并且过期了，是的话就删除。
	// 定期删除: 默认每隔 1s 就随机抽取一些设置了过期时间的 key，检查其是否过期，如果有过期就删除。
	// 定时删除: 某个设置了过期时间的 key，到期后立即删除。
	PERIODIC  ExpirationPolicy = iota // 定期删除
	SCHEDULED                         // 定时删除

)

过期策略

type Float 

type Float interface {
	float32 | float64
}

type HandlerFunc 

type HandlerFunc func(*Request) interface{}

HandlerFunc 定义 goi 使用的请求处理程序

type Int 

type Int interface {
	int | int8 | int16 | int32 | int64
}

type IntAll 

type IntAll interface {
	int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64
}

type Level added in v1.1.0 

type Level uint8
const (
	DEBUG   Level = iota // 打印所有日志
	INFO                 // 打印所有日志
	WARNING              // 打印 Warning、Error 日志
	ERROR                // 打印 Error 日志

)

日志等级

type MetaDataBase 

type MetaDataBase struct {
	ENGINE       string
	NAME         string
	USER         string
	PASSWORD     string
	HOST         string
	PORT         uint16
	SERVICE_NAME string
}

数据库

type MetaLogger 

type MetaLogger struct {
	Name          string                                       // 日志名称
	Path          string                                       // 日志输出路径
	Level         []Level                                      // 日志等级
	Logger        *log.Logger                                  // 日志对象
	File          *os.File                                     // 日志文件对象
	CreateTime    time.Time                                    // 日志创建时间
	SPLIT_SIZE    int64                                        // 日志切割大小，默认为 1G 1024 * 1024 * 1024
	SPLIT_TIME    string                                       // 日志切割大小，默认按天切割
	NewLoggerFunc func() *MetaLogger                           // 自定义初始化日志
	LoggerPrint   func(logger *MetaLogger, log ...interface{}) // 自定义日志输出
}

日志

type MetaSSL added in v1.0.13 

type MetaSSL struct {
	STATUS    bool
	TYPE      string
	CERT_PATH string
	KEY_PATH  string
}

SSL

type Request 

type Request struct {
	Object      *http.Request
	Context     context.Context // 请求上下文
	PathParams  metaValues      // 路由参数
	QueryParams metaValues      // 查询字符串参数
	BodyParams  metaValues      // Body 传参
}

type RequestMiddleware 

type RequestMiddleware func(*Request) interface{} // 请求中间件

type Response 

type Response struct {
	Status int
	Data   interface{}
}

请求响应数据

type ResponseMiddleware 

type ResponseMiddleware func(*Request, http.ResponseWriter) interface{} // 响应中间件

type RouteInfo added in v1.2.0 

type RouteInfo struct {
	Uri          string // 路由
	Desc         string // 简介
	ViewSet      AsView // 视图方法
	IsParent     bool   // 是否是父路由
	ParentRouter string // 父路由
}

路由信息

type UInt 

type UInt interface {
	uint | uint8 | uint16 | uint32 | uint64
}

type ValidationError added in v1.3.0 

type ValidationError interface {
	Error() string
	Response() Response
}

验证器错误类型

func NewValidationError added in v1.3.0 

func NewValidationError(text string, status int) ValidationError

type ViewMiddleware 

type ViewMiddleware func(*Request, HandlerFunc) interface{} // 视图中间件

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.