golang封装业务err（结合iris）

于 2024-01-28 18:17:12 发布
阅读量759 收藏 10
点赞数 5
分类专栏： 框架 文章标签： golang 开发语言 后端 前端 封装 错误码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45565886/article/details/135898233
版权

golang封装业务err

我们有时在web开发时，仅凭httpStatus以及msg是不方便维护和体现我们的业务逻辑的。所以就需要封装我们自己的业务错误。

  • 自定义biz_err
  • 维护err map：errorResponseMap、errorHttpStatusMap

注意：本文主要以演示为主，主要是让大家熟悉封装自定义错误的思路，故而封装的较为简单。大家可根据自己公司需求来进行拓展。

代码仓库地址：https://github.com/ziyifast/ziyifast-code_instruction

项目结构：
在这里插入图片描述

1 err：自定义err，重写打印格式等

1.1 biz_err_demo/error/zerr/errors.go：new方法

  1. 重写控制台打印格式
  2. 封装new方法
  • DefaultBizWrap：不含原始err
  • BizWrap：包含原始err
package zerr

import (
	"errors"
	"fmt"
	"io"
)

func New(message string) error {
	return &fundamental{
		msg:   message,
		stack: callers(),
	}
}

func Errorf(format string, args ...interface{}) error {
	return &fundamental{
		msg:   fmt.Sprintf(format, args...),
		stack: callers(),
	}
}

type fundamental struct {
	msg string
	*stack
}

func (f *fundamental) Error() string { return f.msg }

func (f *fundamental) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		if s.Flag('+') {
			io.WriteString(s, f.msg)
			f.stack.Format(s, verb)
			return
		}
		fallthrough
	case 's':
		io.WriteString(s, f.msg)
	case 'q':
		fmt.Fprintf(s, "%q", f.msg)
	}
}

func WithStack(err error) error {
	if err == nil {
		return nil
	}
	return &withStack{
		err,
		callers(),
	}
}

type withStack struct {
	error
	*stack
}

func (w *withStack) Cause() error { return w.error }

func (w *withStack) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		if s.Flag('+') {
			fmt.Fprintf(s, "%+v", w.Cause())
			w.stack.Format(s, verb)
			return
		}
		fallthrough
	case 's':
		io.WriteString(s, w.Error())
	case 'q':
		fmt.Fprintf(s, "%q", w.Error())
	}
}

func Wrap(err error, message string) error {
	if err == nil {
		return nil
	}
	err = &withMessage{
		cause: err,
		msg:   message,
	}
	return &withStack{
		err,
		callers(),
	}
}

func Trace(err error) error {
	return Wrapf(err, "")
}

func Wrapf(err error, format string, args ...interface{}) error {
	if err == nil {
		return nil
	}
	err = &withMessage{
		cause: err,
		msg:   fmt.Sprintf(format, args...),
	}
	return &withStack{
		err,
		callers(),
	}
}

func WithMessage(err error, message string) error {
	if err == nil {
		return nil
	}
	return &withMessage{
		cause: err,
		msg:   message,
	}
}

func WithMessagef(err error, format string, args ...interface{}) error {
	if err == nil {
		return nil
	}
	return &withMessage{
		cause: err,
		msg:   fmt.Sprintf(format, args...),
	}
}

type withMessage struct {
	cause error
	msg   string
}

func (w *withMessage) Error() string {
	return w.msg + ": " + w.cause.Error()
}

func (w *withMessage) Cause() error {
	return w.cause
}

func (w *withMessage) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		if s.Flag('+') {
			fmt.Fprintf(s, "%+v\n", w.Cause())
			io.WriteString(s, w.msg)
			return
		}
		fallthrough
	case 's', 'q':
		io.WriteString(s, w.Error())
	}
}

func Cause(err error) error {
	type causer interface {
		Cause() error
	}

	for err != nil {
		cause, ok := err.(causer)
		if !ok {
			break
		}
		err = cause.Cause()
	}
	return err
}

func WithCode(err error, code string) error {
	if err == nil {
		return nil
	}
	return &ErrWrap{
		cause: err,
		code:  code,
	}
}

func WithCodef(err error, format string, args ...interface{}) error {
	if err == nil {
		return nil
	}
	return &ErrWrap{
		cause: err,
		code:  fmt.Sprintf(format, args...),
	}
}

type ErrWrap struct {
	cause error
	code  string
	vars  []string
}

func (w *ErrWrap) Vars() []string {
	return w.vars
}

func (w *ErrWrap) Code() string {
	return w.code
}

func (w *ErrWrap) Error() string {
	var msg string
	if w.cause != nil {
		msg += w.cause.Error()
	}
	return msg
}

func (w *ErrWrap) Cause() error {
	return w.cause
}

// Format rewrite format
func (w *ErrWrap) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		if s.Flag('+') {
			fmt.Fprintf(s, "%+v\n", w.Cause())
			io.WriteString(s, "BizCode=["+string(w.code)+"]")
			return
		}
		fallthrough
	case 's', 'q':
		io.WriteString(s, w.Error())
	}
}

func BizWrap(err error, code string, message string, vars ...string) error {
	if err == nil {
		return nil
	}
	codeErr := &ErrWrap{
		cause: err,
		code:  code,
		vars:  vars,
	}
	err = &withMessage{
		cause: codeErr,
		msg:   message,
	}
	return &withStack{
		err,
		callers(),
	}
}

func DefaultBizWrap(code string, vars ...string) error {
	err := errors.New("")
	codeErr := &ErrWrap{
		cause: err,
		code:  code,
		vars:  vars,
	}
	err = &withMessage{
		cause: codeErr,
	}
	return &withStack{
		err,
		callers(),
	}
}

1.2 biz_err_demo/error/zerr/stack.go：堆栈打印格式

定义堆栈打印格式

package zerr

import (
	"fmt"
	"io"
	"path"
	"runtime"
	"strings"
)

type Frame uintptr

func (f Frame) pc() uintptr { return uintptr(f) - 1 }

func (f Frame) file() string {
	fn := runtime.FuncForPC(f.pc())
	if fn == nil {
		return "unknown"
	}
	file, _ := fn.FileLine(f.pc())
	return file
}

func (f Frame) line() int {
	fn := runtime.FuncForPC(f.pc())
	if fn == nil {
		return 0
	}
	_, line := fn.FileLine(f.pc())
	return line
}

func (f Frame) Format(s fmt.State, verb rune) {
	switch verb {
	case 's':
		switch {
		case s.Flag('+'):
			pc := f.pc()
			fn := runtime.FuncForPC(pc)
			if fn == nil {
				io.WriteString(s, "unknown")
			} else {
				file, _ := fn.FileLine(pc)
				fmt.Fprintf(s, "%s\n\t%s", fn.Name(), file)
			}
		default:
			io.WriteString(s, path.Base(f.file()))
		}
	case 'd':
		fmt.Fprintf(s, "%d", f.line())
	case 'n':
		name := runtime.FuncForPC(f.pc()).Name()
		io.WriteString(s, funcname(name))
	case 'v':
		f.Format(s, 's')
		io.WriteString(s, ":")
		f.Format(s, 'd')
	}
}

type StackTrace []Frame

func (st StackTrace) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		switch {
		case s.Flag('+'):
			for _, f := range st {
				fmt.Fprintf(s, "\n%+v", f)
			}
		case s.Flag('#'):
			fmt.Fprintf(s, "%#v", []Frame(st))
		default:
			fmt.Fprintf(s, "%v", []Frame(st))
		}
	case 's':
		fmt.Fprintf(s, "%s", []Frame(st))
	}
}

type stack []uintptr

func (s *stack) Format(st fmt.State, verb rune) {
	switch verb {
	case 'v':
		switch {
		case st.Flag('+'):
			for _, pc := range *s {
				f := Frame(pc)
				fmt.Fprintf(st, "\n%+v", f)
			}
		}
	}
}

func (s *stack) StackTrace() StackTrace {
	f := make([]Frame, len(*s))
	for i := 0; i < len(f); i++ {
		f[i] = Frame((*s)[i])
	}
	return f
}

func callers() *stack {
	const depth = 32
	var pcs [depth]uintptr
	n := runtime.Callers(3, pcs[:])
	if n > 1 {
		n = 1
	}
	var st stack = pcs[0:n]
	return &st
}

func funcname(name string) string {
	i := strings.LastIndex(name, "/")
	name = name[i+1:]
	i = strings.Index(name, ".")
	return name[i+1:]
}

1.3 biz_err_demo/error/zerr/wrap.go：判断err类型

由自定义err，判断是否属于某个err

package zerr

import (
	"errors"
	"reflect"
)

func Unwrap(err error) error {
	u, ok := err.(interface {
		Cause() error
	})
	if !ok {
		return errors.Unwrap(err)
	}
	return u.Cause()
}

func Is(err, target error) bool {
	if target == nil {
		return err == target
	}

	isComparable := reflect.TypeOf(target).Comparable()
	for {
		if isComparable && err == target {
			return true
		}
		if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
			return true
		}
		if err = Unwrap(err); err == nil {
			return false
		}
	}
}

func As(err error, target interface{}) bool {
	if target == nil {
		panic("errors: target cannot be nil")
	}
	val := reflect.ValueOf(target)
	typ := val.Type()
	if typ.Kind() != reflect.Ptr || val.IsNil() {
		panic("errors: target must be a non-nil pointer")
	}
	targetType := typ.Elem()
	if targetType.Kind() != reflect.Interface && !targetType.Implements(errorType) {
		panic("errors: *target must be interface or implement error")
	}
	for err != nil {
		if reflect.TypeOf(err).AssignableTo(targetType) {
			val.Elem().Set(reflect.ValueOf(err))
			return true
		}
		if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
			return true
		}
		err = Unwrap(err)
	}
	return false
}

var errorType = reflect.TypeOf((*error)(nil)).Elem()

1.4 biz_err_demo/error/biz_err/code.go：业务错误码

自定义业务错误码、对应错误信息及对应错误对应的httpStatusCode

package biz_err

import (
	"myTest/demo_home/biz_err_demo/error/zerr"
	"net/http"
	"strings"
)

const (
	Undefined                 = "Undefined"
	OsCreateFileError         = "OsCreateFileError"
	ImageNotSupported         = "ImageNotSupported"
	UsernameOrPasswordInValid = "UsernameOrPasswordInValid"
)

var errorResponseMap = map[string]string{
	OsCreateFileError:         "创建文件失败",
	ImageNotSupported:         "图片格式不支持",
	UsernameOrPasswordInValid: "用户名或密码错误",
}

var errorHttpStatusMap = map[string]int{
	OsCreateFileError:         http.StatusInternalServerError,
	ImageNotSupported:         http.StatusInternalServerError,
	UsernameOrPasswordInValid: http.StatusInternalServerError,
}

func ParseBizErr(err error) (httpStatus int, code, msg string) {
	if err == nil {
		code = Undefined
	}
	vars := make([]string, 0)
	errWrap := new(zerr.ErrWrap)
	var cause error
	if as := zerr.As(err, &errWrap); as {
		code = errWrap.Code()
		cause = errWrap.Cause()
		vars = errWrap.Vars()
	} else {
		code = Undefined
	}
	if code == Undefined {
		var undefinedMsg string
		if err != nil {
			undefinedMsg = err.Error()
		}
		if undefinedMsg == "" || undefinedMsg == ": " {
			undefinedMsg = errorResponseMap[code]
		}
		return errorHttpStatusMap[code], code, undefinedMsg
	}
	if status, ok := errorHttpStatusMap[code]; ok {
		httpStatus = status
	} else {
		httpStatus = http.StatusOK
	}
	if bizMsg, ok := errorResponseMap[code]; ok {
		for _, v := range vars {
			bizMsg = strings.Replace(bizMsg, "%s", v, 1)
		}
		msg = bizMsg
		if cause != nil {
			_, _, causeMsg := ParseBizErr(cause)
			if causeMsg != "" {
				msg += ", " + causeMsg
			} else {
				msg += ", " + errWrap.Error()
			}
		}
	} else {
		msg = errWrap.Error()
	}
	return httpStatus, code, msg
}

func ErrResponse(err error) (httpStatus int, code, msg string) {
	if err == nil {
		code = Undefined
	}
	vars := make([]string, 0)
	errWrap := new(zerr.ErrWrap)
	var cause error
	if as := zerr.As(err, &errWrap); as {
		code = errWrap.Code()
		cause = errWrap.Cause()
		vars = errWrap.Vars()
	} else {
		code = Undefined
	}
	if status, ok := errorHttpStatusMap[code]; ok {
		httpStatus = status
	} else {
		httpStatus = http.StatusOK
	}
	if bizMsg, ok := errorResponseMap[code]; ok {
		for _, v := range vars {
			bizMsg = strings.Replace(bizMsg, "%s", v, 1)
		}
		msg = bizMsg
		if cause != nil {
			_, _, causeMsg := ErrResponse(cause)
			if causeMsg != "" {
				msg += causeMsg
			} else {
				msg += errWrap.Error()
			}
		}
	} else {
		msg = errWrap.Error()
	}
	return httpStatus, code, msg
}

2 controller：封装base_controller

2.1 biz_err_demo/constant/constant.go

package constant

const (
	ContentTypeJson = "application/json"
	ContentTypeXml  = "application/xml"
)

2.2 biz_err_demo/controller/base_controller.go

package controller

import (
	"encoding/json"
	"encoding/xml"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/mvc"
	"github.com/sirupsen/logrus"
	"myTest/demo_home/biz_err_demo/constant"
	"myTest/demo_home/biz_err_demo/error/biz_err"
	"myTest/demo_home/biz_err_demo/response"
	"net/http"
)

type BaseController struct {
	Ctx iris.Context
}

func commonResp(errMsg string, httpCode int, returnCode response.Code, content interface{}) mvc.Response {
	payload := &response.JsonResponse{
		Code:    returnCode,
		Msg:     errMsg,
		Content: content,
	}

	contentDetail, err := json.Marshal(payload)
	if err != nil {
		logrus.Infof("marshal json response error %v", err)
	}

	return mvc.Response{
		Code:        httpCode,
		Content:     contentDetail,
		ContentType: constant.ContentTypeJson,
	}
}

func (c *BaseController) Xml(httpCode int, content interface{}) mvc.Response {
	payload, err := xml.Marshal(content)
	if err != nil {
		logrus.Errorf("marshal xml response error %v", err)
	}
	return c.XmlRaw(httpCode, payload)
}

func (c *BaseController) XmlOK(content interface{}) mvc.Response {
	payload, err := xml.Marshal(content)
	if err != nil {
		logrus.Errorf("marshal xml response error %v", err)
	}
	return c.XmlRaw(http.StatusOK, payload)
}

func (c *BaseController) XmlRaw(httpCode int, content []byte) mvc.Response {
	return mvc.Response{
		Code:        httpCode,
		Content:     content,
		ContentType: constant.ContentTypeXml,
	}
}

func (c *BaseController) JsonBizError(err error) mvc.Response {
	httpStatus, code, msg := biz_err.ErrResponse(err)
	return commonResp(msg, httpStatus, response.Code(code), nil)
}

2.3 biz_err_demo/controller/test_biz_controller.go

package controller

import (
	"errors"
	"github.com/kataras/iris/v12/mvc"
	"myTest/demo_home/biz_err_demo/error/biz_err"
	"myTest/demo_home/biz_err_demo/error/zerr"
	"myTest/demo_home/biz_err_demo/response"
	"net/http"
)

type TestBizController struct {
	BaseController
}

func (t *TestBizController) BeforeActivation(b mvc.BeforeActivation) {
	b.Handle(http.MethodGet, "/testBizErr", "TestBizErr")
}

func (t *TestBizController) TestBizErr() mvc.Result {
	err1 := errors.New("")
	err := zerr.BizWrap(err1, biz_err.UsernameOrPasswordInValid, "")
	return response.JsonBizError(err)
}

3 封装response

3.1 biz_err_demo/response/json_response.go

package response

import (
	"encoding/json"
	"github.com/kataras/iris/v12/mvc"
	"github.com/sirupsen/logrus"
	"myTest/demo_home/biz_err_demo/constant"
	"myTest/demo_home/biz_err_demo/error/biz_err"
)

type Code string

type JsonResponse struct {
	Code    Code        `json:"code"`
	Msg     string      `json:"msg"`
	Content interface{} `json:"content,omitempty"`
}

func JsonBizError(err error) mvc.Response {
	httpStatus, code, msg := biz_err.ErrResponse(err)
	return commonResp(msg, httpStatus, Code(code), nil)
}

func commonResp(errMsg string, httpCode int, returnCode Code, content interface{}) mvc.Response {
	payload := &JsonResponse{
		Code:    returnCode,
		Msg:     errMsg,
		Content: content,
	}

	contentDetail, err := json.Marshal(payload)
	if err != nil {
		logrus.Errorf("%v", err)
	}

	return mvc.Response{
		Code:        httpCode,
		Content:     contentDetail,
		ContentType: constant.ContentTypeJson,
	}
}

4 测试效果

4.1 biz_err_demo/test/main.go

package main

import (
	"errors"
	"github.com/sirupsen/logrus"
	"myTest/demo_home/biz_err_demo/error/biz_err"
	"myTest/demo_home/biz_err_demo/error/zerr"
)

func init() {
	logrus.SetReportCaller(true) // 设置日志是否记录被调用的位置，默认值为 false
}

func main() {
	TestWithNoSourceErr()
	TestWithSourceErr()
	TestParseBizErr()
}

func TestWithNoSourceErr() {
	err := zerr.DefaultBizWrap(biz_err.UsernameOrPasswordInValid, "")
	logrus.Errorf("TestWithNoSourceErr %+v", err)
}

func TestWithSourceErr() {
	err := errors.New("invalid image")
	err = zerr.BizWrap(err, biz_err.ImageNotSupported, "")
	logrus.Errorf("TestWithSourceErr %+v", err)
}

func TestParseBizErr() {
	err := errors.New("")
	err = zerr.BizWrap(err, biz_err.ImageNotSupported, "")
	httpStatus, bizCode, msg := biz_err.ParseBizErr(err)
	logrus.Errorf("httpStatus:%d bizCode:%s msg:%s", httpStatus, bizCode, msg)
}

在这里插入图片描述

4.2 biz_err_demo/main.go

package main

import (
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/mvc"
	"myTest/demo_home/biz_err_demo/controller"
)

func main() {
	app := iris.New()
	mvc.New(app).Handle(new(controller.TestBizController))
	app.Listen(":8088", nil)
}

在这里插入图片描述

这样前端就能直接根据我们的业务错误码展示对应msg信息

NPE~
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang对MongoDB数据库的操作简单封装教程
01-03
Golang 对MongoDB的操作简单封装 使用MongoDB的Go驱动库 mgo,对MongoDB的操作做一下简单封装 mgo（音mango）是MongoDB的Go语言驱动，它用基于Go语法的简单API实现了丰富的特性，并经过良好测试。 初始化 操作没有...
golang 的 gin 框架基础封装
最新发布
05-11
无论个人、团队、企业都能拿来即用的gin框架基础封装，现在已经包含了gin框架类似mvc模式的封装、路由、数据库、中间件、动态读取配置文件等都已实现； 后续会开发包含基础注册等功能，包括很多公共方法的封装，目的...
Golang：error包错误处理
彭世瑜的博客
11-11 670
【代码】Golang：error包错误处理。
golang 语言中关于err的函数的封装使用
wtt234的专栏
05-26 540
golang 语言中关于err的函数的封装使用 解决总是写err的内容 ： // err制定的一个函数，后面的测试过程中直接调用即可 func Errimport(err error){ if err!=nil{ log.Fatal(err) } }
Golang error 处理思路分享【详】
qq_41257365的博客
10-15 1617
针对golang中 error 的处理思路
golang的错误处理
公众号
10-20 630
通常在golang中使用错误处理都是这样做的：    err := foo()    if err != nil {        return err    }但是如果该函数需要多次调用，那么每次调用都需要进行错误处理：    var err error    var param1, param2 int    err = foo(param1)    if err != nil {      
Golang_09: Go语言 错误处理(error)、链式/树状error、panic与recover
谢TS的博客
05-25 1005
Go 调用可能发生异常的函数时，通过多返回一个附加结果作为错误值，习惯上将错误值作为最后一个返回结果。如果返回的错误值为错误类型的零值（如 nil），表示没有发生错误。
go-utils:golang封装库
03-09
实用程序去建立-mod = vendor
Docker与Golang的巧妙结合
09-21
主要介绍了Docker与Golang的巧妙结合的相关资料,需要的朋友可以参考下
golang 定时器 封装Cron 支持秒、分、小时、天 支持多态
03-18
golang 手写定时器 封装Cron 支持秒、分、小时、天。 支持多态。 说明: 1.DoCron() 方法初始化定时器 2.AddJob添加定时器 3.UpdateJob修改定时器 4.DeleteJob删除定时器 5.GetAllCrons获取定时器列表 6.支持多态 ...
golang版本的RabbitMQ消息订阅的封装,多生产者多消费者。
04-14
golang版本的RabbitMQ消息订阅的封装，可以多个生产者，多个消息订阅者，每个队列可以创建多个协程处理; 可能有些消费者需求需要分布式部署，那需要指定队列名，并且需要设置队列持久化，以及排他性QueueDeclare....
iris-blog-server：golang虹膜博客服务器
02-10
虹膜博客服务器golang虹膜博客服务器
利用golang实现封装trycatch异常处理实例代码
01-20
社区不少人在谈论 golang 为毛不用trycatch模式，而采用苛刻的recovery、panic、defer组合…. 从网上整了一个trycatch包，感觉不错，拿出来分享下…下面话不多说，来一起看看详细的介绍。 示例代码 package main ...
golang基于zap日志库封装.rar
01-14
golang的zap日志库简易封装,包括gin,xorm,gorm日志输出到文件,自定义日志级别 示例移步[https://github.com/restoflife] 查看
基于Golang语言结合领域驱动设计（DDD) 实现o2o业务模型项目源码
03-24
基于Golang语言结合领域驱动设计（DDD) 实现o2o业务模型项目源码，支持线上商店，线下门店；多渠道（商户)、多门店、商品、规格SKU、快照、订单、促销、支付、配送等功能
Golang之错误处理
fourierr的博客
11-13 857
1、错误只在逻辑的最外层处理一次，底层只返回错误。 2、底层除了返回错误外，要对原始错误进行包装，增加错误信息、调用栈等这些有利于排查的上下文信息。 例子： //只附加新的信息 funcWithMessage(errerror,messagestring)error 如： if err != nil { errors.WithMessage(err, "could not read config") } //只附加调用堆栈信息 funcWithStack(errerror)err...
Go 1.13 errors 新特性（错误封装及 Unwrap、Is、As函数）的使用
Bagley Pan的博客
08-01 1283
Go 1.13 中新增了 errors 的一些特性，有助于我们更优雅的处理业务逻辑中报错的问题。 本文主要展示 errors 包中新增方法的用法。
Go 中的 error 居然可以这样封装
EDDYCJY的博客
07-06 1587
本文由周浩翻译自：https://medium.com/spectro-cloud/decorating-go-error-d1db60bb9249，ironbox和Tang Ruilin...
Golang通脉之错误处理
羌
10-26 295
在实际工程项目中，总是通过程序的错误信息快速定位问题，但是又不希望错误处理代码写的冗余而又啰嗦。Go语言没有提供像Java、C#语言中的try...catch异常处理方式，而是通过函数返回值逐层往上抛。这种设计，鼓励在代码中显式的检查错误，而非忽略错误，好处就是避免漏掉本应处理的错误。但是带来一个弊端，让代码冗余。 什么是错误 错误指的是可能出现问题的地方出现了问题。如打开一个文件时失败，这种情况是在意料之中的 。 而异常指的是不应该出现问题的地方出现了问题。比如引用了空指针，这种情况在在意料之外的。可见，
golang iris session
05-19
在 Iris 中使用 Session 需要使用第三方库 iris/sessions。这个库提供了一个简单而强大的 Session 管理器，使得在应用程序中使用 Session 变得非常容易。 首先，需要在应用程序中导入 iris/sessions 包。可以使用 go get 命令来安装它： ``` go get -u github.com/kataras/iris/sessions ``` 然后，创建一个 Session 管理器： ``` package main import ( "github.com/kataras/iris/v12" "github.com/kataras/iris/v12/sessions" ) func main() { app := iris.New() // 创建一个新的 Session 管理器 manager := sessions.New(sessions.Config{ Cookie: "myapp_session", Expires: 24 * time.Hour, AllowReclaim: true, }) // 将 Session 管理器注册到应用程序中 app.Use(manager.Handler()) // ... } ``` 在上面的代码中，我们创建了一个名为 manager 的 Session 管理器，并将其注册到应用程序中。这将使所有的路由处理程序都能够访问 Session 对象。 现在，我们可以在路由处理程序中使用 Session 了： ``` func myHandler(ctx iris.Context) { // 从会话中获取一个名为 "username" 的值 username := ctx.Session().GetString("username") if username != "" { ctx.WriteString("Hello, " + username + "!") } else { ctx.WriteString("Please log in first.") } } ``` 在上面的代码中，我们使用 Session 对象的 GetString 方法从 Session 中获取一个名为 "username" 的值。如果该值存在，则向客户端发送一个欢迎消息，否则提示用户先登录。 最后，我们还可以将值保存到 Session 中： ``` func loginHandler(ctx iris.Context) { username := ctx.FormValue("username") // 将用户名保存到会话中 ctx.Session().Set("username", username) ctx.WriteString("Welcome, " + username + "!") } ``` 在上面的代码中，我们使用 Session 对象的 Set 方法将用户名保存到 Session 中，以便后续使用。 这就是在 Iris 中使用 Session 的基本方法。要了解更多信息，请参阅官方文档：https://github.com/kataras/iris/tree/v12/sessions。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值