golang string 加号连接性能慢_手把手教你用Golang封装一款适合自己使用的Web编程框架

以下文章来源于非正式解决方案 ，作者winlion

非正式解决方案

思考链接价值,非正式解决方案,既扯高大上如人工智能、大数据，也关注码农日常如分布式、java和golang,每天分享瞎想的东西。

MVC 应用一般结构

目录结构说明如下

名称内容model模型层目录,类比Java 中的entityview视图层,存放所有templete模板ctrl控制器层, 存放全部控制器service服务层,类比Java里面的servicehtml一些静态资源页面util核心工具包,Md5加密,返回数据封装等asset静态资源目录,存放js/css/image等args封装全部请求参数对象mnt上传文件的存放目录app.dev.conf开发环境配置文件app.prod.conf生产环境配置文件start.sh/start.bat启动脚本build.sh/build.bat打包脚本main.go主应用程序文件

主程序结构

主程序主要做各种初始化工作

func main() {    //解析配置文件    fpath  := flag.String("c","app.dev.conf","config file path")    flag.Parse()    _,err:=util.Parse(*fpath)    if err!=nil{        fmt.Sprintf("error when %s",err.Error())        return    }    //配置日志    logmap := util.GetSec("log")    service.InitLog(logmap)    //初始化数据库    dbmap := util.GetSec("database")    service.InitDb(dbmap)    //注册funcmap    ctrl.RegisterFuncMap()    //控制器    ctrl.RegisterCtrl()    //静态资源文件    fileservermap := util.GetSec("fileserver")    ctrl.InitFileServer(fileservermap)    //初始化session    sessioncfg:=util.GetSec("session")    util.StartSession(sessioncfg)    appcfg := util.GetSec("app")    //视图控制器    ctrl.RegisterView(appcfg)    fmt.Println("http ListenAndServe " + appcfg["addr"])    //打开服务器监听http    err = http.ListenAndServe(appcfg["addr"], nil)    if err!=nil{        fmt.Println(err.Error())        log.Println(err.Error())    }}

配置文件

3.1 配置文件解析

使用配置文件开发包，如github.com/Unknwon/goconfig 包。

 //util/config.govar cfg *goconfig.ConfigFilevar cfgmap map[string]map[string]string = make(map[string]map[string]string)var filepath string//解析peizfunc Parse(fpath string)(c map[string]map[string]string ,err error){    cfg, err := goconfig.LoadConfigFile(fpath)    filepath = fpath    sec :=cfg.GetSectionList()    for _,v :=range sec{        cfgmap[v]=make(map[string]string,0)        keys := cfg.GetKeyList(v)        for _,b:= range keys{            cfgmap[v][b],_ = cfg.GetValue(v,b)        }    }    return cfgmap,err}//全部都存放在存放func GetAllCfg()(c map[string]map[string]string){    return cfgmap}//重新刷新配置文件func ReloadAllCfg()(c map[string]map[string]string){    return return Parse(filepath)}

调用案列

util.GetAllCfg()["app"]["port"]

3.2 监听配置文件并自动刷新配置

使用github.com/fsnotify/fsnotify包，装时候注意，一个函数里面如果有参数共享，应该放到一个携程里。

//监听文件func WatchConfig(filepath ...string) {    //创建一个监控对象    go func() {        watch, err := fsnotify.NewWatcher()        if err != nil {            log.Fatal(err)        }        defer watch.Close()        //添加要监控的对象，文件或文件夹        for _, fpath := range filepath {            err = watch.Add(fpath)            if err != nil {                log.Fatal(err)            }            fmt.Println("WatchConfig " + fpath)        }        for {            select {            case ev := 

fsnotify 支持很多种事件监听，一般在 Write 事件刷新配置文件

//判断事件发生的类型，如下5种// Create 创建// Write 写入// Remove 删除// Rename 重命名// Chmod 修改权限if ev.Op&fsnotify.Create == fsnotify.Create {    log.Println("创建文件 : ", ev.Name);}if ev.Op&fsnotify.Write == fsnotify.Write {    log.Println("写入文件 : ", ev.Name);}if ev.Op&fsnotify.Remove == fsnotify.Remove {    log.Println("删除文件 : ", ev.Name);}if ev.Op&fsnotify.Rename == fsnotify.Rename {    log.Println("重命名文件 : ", ev.Name);}if ev.Op&fsnotify.Chmod == fsnotify.Chmod {    log.Println("修改权限 : ", ev.Name);}

3.3 区分系统级配置和用户级配置

系统级配置参数 假设修改了会影响整个应用，需要另起服务的我们称之为系统级配置，修改了参数，往需要进行相应的操作。如修改了数据库连接地址，需要重置数据库连接操作。修改了应用服务器端口，则需要重启应用服务。

用户级配置参数 如微信公众号 appsecret，每次调用的时候会从配置中获取，因此只需要重新加载数据即可。

3.4 配置内容缓存

需要将配置文件内容缓存到 map 中。 需要考虑到 map 的并发操作。

实体层(model)写法

4.1 状态变量定义在实体文件内部

//model/user.go//用户性别和角色const (    WOMEN=2    MAN=1    Unknow=0    ROLE_ADMIN =1    ROLE_USER=0)type User struct {Id   int64  `xorm:"pk autoincr BIGINT(20)" form:"id" json:"id"`NickName  string `xorm:"VARCHAR(40)" form:"nickName" json:"nickName"`Openid     string  `xorm:"VARCHAR(40)" form:"openid" json:"openid"`Mobile     string `xorm:"VARCHAR(15)" form:"mobile" json:"mobile"`Passwd     string  `xorm:"VARCHAR(40)" form:"passwd" json:"-"`Role       int      `xorm:"int(11)" form:"role" json:"role"`Enable     int     `xorm:"int(11)" form:"enable" json:"enable"`Gender     int     `xorm:"int(11)" form:"gender" json:"gender"`}

在如上代码中，常用角色变量 ROLE_USER和ROLE_ADMIN 定义在同一个文件中，便于阅读。

4.2 为实体添加 tag

实体和表结构对应，一定要定义 Form 和 Json tag。这样可以提高系统适用性，为什么呢？因为可以适配前端以各种 Content-Type 提交数据如。后端统一用该实体接收数据即可。

//urlencode类application/x-www-form-urlencoded格式mobile=18273252300&passwd=123456//json类application/x-www-form-urlencoded格式{"mobile":"18273252315","passwd":"123456"}

4.3 统一 tag 参数命名方式

约定统一使用驼峰式或者下划线标记。如下，建议使用驼峰式。

#驼峰NickName  string `xorm:"VARCHAR(40)" form:"nickName" json:"nickName"`#下划线NickName  string `xorm:"VARCHAR(40)" form:"nick_name" json:"nick_name"`

模板(view)层配置

如下几点需要注意

5.1 模板文件和模板名称关联

关联便于代码管理和阅读。模板位置 /view/demo/index.html，模板内容如下。

{{define "demo/index"}}

Hello,Modal

{{end}}

外部调用方法如下，大家能很自然知道模板文件位置。

http://localhost/demo/index

5.2 一个函数搞定全部 Html 请求类的页面

主要是为了程序员生活更美好(早点下班+偷懒)。

//ctrl/base.gofunc RegisterPage(isDev bool) {    //初始化一个全局的模板变量    GlobTemplete := template.New("root")    //把一些函数添加进去,这样页面里面就可以使用函数啦    GlobTemplete.Funcs(GetFuncMap())    //解析模板 ,demo/index => 模板    GlobTemplete, err := GlobTemplete.ParseGlob("view/**/*")    for _, templete := range GlobTemplete.Templates() {        tplname := templete.Name()        patern := "/" + tplname        fmt.Printf("register templete  %s ==> %s", patern, tplname)        //这里就是 /demo/index  这个url 和对应的处理函数之间的关系        http.HandleFunc(patern, func(w http.ResponseWriter, req *http.Request) {            fmt.Println(patern + "=>" + tplname)            if isDev {                GlobTemplete := template.New("root")                GlobTemplete.Funcs(GetFuncMap())                GlobTemplete, err = GlobTemplete.ParseGlob("view/**/*")                for _, v := range GlobTemplete.Templates() {                    if v.Name() == tplname {                        templete = v                    }                }            }            err = templete.ExecuteTemplate(w, tplname, nil)            if err != nil {                fmt.Println(err.Error())            }        })    }}//在main.go中初始化func main(){    ///  ctrl.RegisterPage(true)    //}

外部调用方法如下，大家能很自然知道模板文件位置。

http://localhost/demo/index

5.3 添加调试模式支持

为什么要添加调试模式支持?因为调试模式状态下，我们修改来了页面模板，需要立即看到页面内容，而不需要重启应用。核心代码如下，即在调试模式状态下，每次请求都重新解析模板。

if isDev {    GlobTemplete := template.New("root")    GlobTemplete.Funcs(GetFuncMap())    GlobTemplete, err = GlobTemplete.ParseGlob("view/**/*")    for _, v := range GlobTemplete.Templates() {                    if v.Name() == tplname {                        templete = v                    }        }    }

由上可见，调试模式效率是非常低的，我们不应该在生产环境采用调试模式。

5.4 添加数据注入

应用场景是在每个页面中都需要使用 session 中的用户 ID 数据。方法是在 RegisterPage 函数内部模板templete.ExecuteTemplate(w, tplname, nil)处秀修改成如下代码

//从session中获取用户信息user := loadDataFromSession(req)err = templete.ExecuteTemplate(w, tplname, user)

前端模板调用代码如下

{{define "demo/index"}}

Hello,Modal ,User id is {{.Id}}

{{end}}

返回结果

Hello,Modal ,User id is xxx

5.5 在页面使用函数

在 RegisterPage 方法内定义一个 funMap

//ctrl/funcmap.govar resFuncMap template.FuncMap = make(template.FuncMap)func hello (){    return "hello"}func hello2 (test string){    return "hello" + test}//初始化方法func RegisterFuncMap(){    resFuncMap ["hello"]=hello}

main.go 中初始化

//在main.go中初始化func main(){    ///  ctrl.RegisterFuncMap()    //}

前端模板调用代码如下

{{define "demo/index"}}

Hello,Modal ,hello func retutn {{hello}}Hello,Modal ,hello2 func retutn {{hello2 "参数2"}}

{{end}}

返回结果

Hello,Modal ,hello func retutn helloHello,Modal ,hello func retutn hello2参数2

5.6 多多使用 templete 方法

主要使用场景是分角色菜单，用户

{{define "demo/memo"}}{{if eq .Role 1}}菜单内容1{{else if eq .Role 2}}菜单内容2{{end}}{{end}}

其他页面统一调用,进行角色菜单等控制。

{{define "demo/index"}}

{{templete "demo/menu"}}Hello,Modal ,hello func retutn {{hello}}Hello,Modal ,hello2 func retutn {{hello2 "参数2"}}

{{end}}

控制器层(ctrl)

控制器层主要处理对外接口

6.1 一个典型的控制器结构**

import (    ///很多包      )//定义个一个控制器对象type UserCtrl struct {}//将url和处理函数绑定func  ( ctrl *UserCtrl)Router(){    Router("/user/login",ctrl.authwithcode)}//定义用户处理函数var userService service.UserService//用户通过小程序登录处理函数,输入code//通过util.RespOk 或者util.RespFail输出func( ctrl * UserCtrl)authwithcode(w http.ResponseWriter, req *http.Request) {    var requestdata args.AuthArg    util.Bind(req,&requestdata)    cfgminapp := util.GetSec("miniapp")    resp,err := util.Code2Session(cfgminapp["appid"],cfgminapp["secret"],requestdata.Code)    if err!=nil{        util.RespFail(w,err.Error())        return    }    requestdata.User.Openid = resp.Openid        requestdata.User.SessionKey = resp.SessionKey    u,err:= userService.LoginWithOpenId(requestdata.User)    if err!=nil{        util.RespFail(w,err.Error())    }else{        util.RespOk(w,model.User{            Ticket:u.Ticket,            ClientId:u.ClientId,            Role:u.Role,        })    }}

6.2 数据和参数绑定

所有参数都需要可预期在一个结构体里面。这样整个系统编程将变得非常简单。在上 面函数中，通过如下代码实现参数绑定

var requestdata args.AuthArgutil.Bind(req,&requestdata)

其中 args.AuthArg 对象定义如下

package argsimport "../model"type AuthArg struct {    PageArg    model.User    Code string `json:"code" form:"code"`    Kword string `json:"kword" form:"kword"`    Passwd string `json:"passwd" form:"passwd"`}

args 作用是存放一切请求参数。每个业务都建议定义一个 arg。每个 arg 都有一个公共属性 PageArg。PageArg 定义如下

import (    "fmt"    "time")//常用的搜索,大家可以自行添加type PageArg struct {    Pagefrom int  `json:"pagefrom" form:"pagefrom"`    Pagesize int  `json:"pagesize" form:"pagesize"`    Kword string  `json:"kword" form:"kword"`    Asc string  `json:"asc" form:"asc"`    Desc string     `json:"desc" form:"desc"`    Stat int    `json:"stat" form:"stat"`    Datefrom time.Time  `json:"datafrom" form:"datafrom"`    Dateto time.Time    `json:"dateto" form:"dateto"`    Total  int64        `json:"total" form:"total"`}//获得分页大小func (p*PageArg) GetPageSize() int{    if p.Pagesize==0{        return 100    }else{        return p.Pagesize    }}//获得分页当前第几页func (p*PageArg) GetPageFrom() int{    if p.Pagefrom<0{        return 0    }else{        return p.Pagefrom    }}//获得排序 ID DESC ，前端传递参数 desc=排序字段 或者asc=排序字段func (p*PageArg) GetOrderBy() string{    if len(p.Asc)>0{        return fmt.Sprintf(" %s asc",p.Asc)    } else if len(p.Desc)>0{        return fmt.Sprintf(" %s desc",p.Desc)    }else{        return ""    }}

6.3 参数绑定核心函数 util.Bind

大体结构如下

func Bind(req *http.Request,obj interface{}) error{    contentType := req.Header.Get("Content-Type")    //如果是简单的json,那么直接用JSON解码    if strings.Contains(strings.ToLower(contentType),"application/json"){        return  BindJson(req,obj)    }    //如果是其他的urlencode那么就用BindForm去处理    if strings.Contains(strings.ToLower(contentType),"application/x-www-form-urlencoded"){        return   BindForm(req,obj)    }    //可以自行扩展xml    if strings.Contains(strings.ToLower(contentType),"text/xml"){        return   BindXml(req,obj)    }    return errors.New("当前方法暂不支持")}

以 BindJson 为例子

func BindJson(req *http.Request,obj interface{}) error{    s, err := ioutil.ReadAll(req.Body) //把  body 内容读入字符串    if err!=nil{        return err    }    err = json.Unmarshal(s,obj)    return err}

可能大家更关心 BindForm，篇幅太长，大家可以移步

https://www.github/winlion/restgo-admin

6.4 封装返回函数

一般封装一个底层 JSON，然后根据返回成功或失败响应对应的 code

/util/resp.gopackage utilimport (    "net/http"    "encoding/json"    "fmt")//定义个通用的结构体用于装载返回的数据type H struct {    Code int    `json:"code"`    Rows interface{} `json:"rows,omitempty"`    Data interface{} `json:"data,omitempty"`    Msg string `json:"msg,omitempty"`    Total interface{} `json:"total,omitempty"`}//返回Json的底层方法func RespJson(w http.ResponseWriter,data interface{}){        header :=w.Header()        header.Set("Content-Type","application/json;charset=utf-8")        w.WriteHeader(http.StatusOK)        ret,err :=json.Marshal(data)        if err!=nil{            fmt.Println(err.Error())        }        w.Write(ret)}//当操作成功返回Ok,func RespOk(w http.ResponseWriter,data interface{}){    RespJson(w,H{        Code:http.StatusOK,        Data:data,    })}//当操作失败返回Error,func RespFail(w http.ResponseWriter,msg string){    RespJson(w,H{        Code:http.StatusNotFound,        Msg :msg,    })}

服务层(service)实现

7.1 服务层一般结构

以订单管理为例

package serviceimport (    "../model"    "../args"    "github.com/go-xorm/xorm"        "log"    "github.com/pkg/errors"    "encoding/json"    "time")type OrderService struct {}//构造条件func (service *OrderService)buildCond(arg args.PageArg)(*xorm.Session){    orm := DBengin.Where("id > ?",0)    if(!arg.Datefrom.IsZero()){        orm = orm.And("createat >= ?",arg.Datefrom.String())    }    if(!arg.Dateto.IsZero()){        orm = orm.And("createat 0){        orm = orm.And("seller = ?",arg.Seller)    }    if (arg.Buyer>0){        orm = orm.And("buyer = ?",arg.Buyer)    }    if (arg.Stat>0){        orm = orm.And("stat = ?",arg.Stat)    }    return orm}//增加func (service *OrderService) Create(order model.Order) (model.Order,err){    _,err = DBengin.InsertOne(&order)    if err!=nil{        log.Println(err.Error())    }    return order}//删除func (service *OrderService) Delete(order model.Order) (error){    return nil}//修改func (service *OrderService) Create(order model.Order) (model.Order,err){    _,err = DBengin.InsertOne(&order)    if err!=nil{        log.Println(err.Error())    }    return order}//搜索func (service *OrderService) Search(orderArg args.OrderArg) ([]model.Order, error){var ret []model.Order = make([]model.Order,0)return  ret,nil}//查询某一个func (service *OrderService) Create(order model.Order) (model.Order){    _,err := DBengin.InsertOne(&order)    if err!=nil{        log.Println(err.Error())    }    return order}

一般需要构建如下几类函数，具体随业务而定

名称内容Create添加Update修改Search搜索,返回列表Find返回某一个对象Delete删除buildCond构建条件函数Count符合某一条件的记录数目

7.2 条件统一管理

我们可以用类似于如下函数来统一管理查询条件，该函数输出参数，输出一个 session。

func (service *OrderService)buildCond(arg args.PageArg)(*xorm.Session)

条件规范化可以让应用更灵活，让业务更清晰。如果不规范，楼主曾经经历的教训可能也会撞上你。

7.3 连接数据库

数据库建议使用 xorm。 在 server 包目录下新建 init.go 在其中实现数据库的初始化

//定义全局变量DBengin var DBengin *xorm.Engine//定义初始化函数InitDb,dbmap是数据库配置参数，=来自于外部参数func InitDb(dbmap map[string]string){    driverName     := dbmap["driveName"]    dataSourceName := dbmap["dataSourceName"]    showsql :=       dbmap["showSql"]!="false"    maxIdle,_ :=        strconv.Atoi(dbmap["maxIdle"])    maxOpen,_ :=       strconv.Atoi(dbmap["maxOpen"])    sync     :=      dbmap["sync"]=="true"    dbengin , err := xorm.NewEngine(driverName, dataSourceName)    if err != nil {        panic("data source init error ==>"+err.Error())    }    if sync{        dbengin.Sync2(new(model.User),            new(model.Item),            new(model.Order),            new(model.User),            )    }    dbengin.ShowSQL(showsql)    dbengin.SetMaxIdleConns(maxIdle)    dbengin.SetMaxOpenConns(maxOpen)    dbengin.SetConnMaxLifetime(5*time.Second)    DBengin = dbengin}

main.go 中初始化数据库

func main(){    //    dbmap = util.GetSec("database")     server.InitDb(dbmap)    //}

具体使用可以参考 Xorm

func (service *OrderService) Create(order model.Order) (model.Order){    //就是这么用的    _,err := DBengin.InsertOne(&order)    if err!=nil{        log.Println(err.Error())    }    return order}

路由

8.1 路由功能怎实现

在每一个 ctrl 中都定义一个 Router 函数

func  ( ctrl *UserCtrl)Router(){    Router("/open/register",ctrl.Register)    Router("/open/authwithpwd",ctrl.authwithpwd)    Router("/user/find",ctrl.Find)    Router("/user/quit",ctrl.quit)    Router("/open/authwithcode",ctrl.authwithcode)}

这些函数调用了 Router 方法，该方法本质上是对 http.HanderFunc 的封装

//ctrl/base.gofunc Router(pantern string, fun func(w http.ResponseWriter, req *http.Request)) {    http.HandleFunc(pantern, func(w http.ResponseWriter, req *http.Request) {      fun(w, req)    })}

定义路由注册函数

//注册控制器func RegisterCtrl() {    new(UserCtrl).Router()    new(OpenCtrl).Router()    new(AttachCtrl).Router()}

注册路由 在 main.go 中完成路由注册

func main(){    //      ctrl.RegisterCtrl()    //}

8.2 支持 Post/Get/Any

解决思路如下 首先在 ctrl/base.go 里面定义一个 map

PostRouterMap := make(map[string]HandFunc)GetRouterMap := make(map[string]HandFunc)

接着定义路由绑定函数

type Handlefunc func(w http.ResponseWriter,req *http.Request)func Post(formate string,handlefunc func(w http.ResponseWriter,req *http.Request)){    http.HandleFunc(formate,func(w http.ResponseWriter,req *http.Request){            if req.Method==http.MethodPost {                handlefunc(w,req)            }else{                //not sourport 处理            }    })}func Get(formate string,handlefunc func(w http.ResponseWriter,req *http.Request)){http.HandleFunc(formate,func(w http.ResponseWriter,req *http.Request){        if req.Method==http.MethodGet {            handlefunc(w,req)        }else{            //not sourport 处理        }    })}//支持任意方式func Any(formate string,handlefunc func(w http.ResponseWriter,req *http.Request)){http.HandleFunc(formate,func(w http.ResponseWriter,req *http.Request){        handlefunc(w,req)    })}

8.3 支持正则

首先需要定义默认路由。RegisterRegExRouter() 中定义了默认路由 http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request)。任何找不到的路由都会进入这个。

//这一个专门存uri和处理函数之间关系的字典var RegExRouterMap map[string]func(w http.ResponseWriter, req *http.Request) = make(map[string]func(w http.ResponseWriter, req *http.Request), 0)//这是一个存储Uri和对应正则表达式的字典以后就不要编译啦。var RegexpMatchMap map[string]*regexp.Regexp = make(map[string]*regexp.Regexp, 0)func RegExRouter(pantern string, fun func(w http.ResponseWriter, req *http.Request)) {    RegExRouterMap[pantern] = fun    //形成映射关系    RegexpMatchMap[pantern],_ = regexp.Compile(pantern)}//没有找到需要一个默认404func notfound(w http.ResponseWriter, req *http.Request){    w.Write([]byte("404 NOT FOUNT"))}func RegisterRegExRouter(){    http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {        uris :=  strings.Split(req.RequestURI,"?")        uri := uris[0]        handlefunc :=  notfound        for p,regm := range  RegexpMatchMap{            if regm.MatchString(uri){                handlefunc = RegExRouterMap[p]                break            }        }        handlefunc(w,req)    })}

在路由注册中初始化

//注册控制器func RegisterCtrl() {    //new(AttachCtrl).Router()    RegisterRegExRouter()}

现在我们可以在控制器页面通过 RegExRouter 添加正则路由啦

//ctrl/user.gofunc (ctrl *UserCtrl) Router() {    Router("/open/authwithcode", ctrl.authwithcode)    RegExRouter("/d/.*", ctrl.regtext)}func (ctrl *UserCtrl) regtext(w http.ResponseWriter, req *http.Request) {    util.RespOk(w, req.RequestURI)}

客户端请求

http://localhost/d/12345678977

响应数据

{"code":200,"data":"/d/12345678977"}

8.4 404 没找到

在如上所示中定义了 notfound 函数，当没有任何一个匹配对象时候，进入这个函数。

//没有找到需要一个默认404func notfound(w http.ResponseWriter, req *http.Request){    w.Write([]byte("404 NOT FOUNT"))}

8.5 实现拦截器功能

我们可以在 Router 方法里面实现拦截器功能，主要用来做鉴权，日志记录等

func Router(pantern string, fun func(w http.ResponseWriter, req *http.Request)) {    http.HandleFunc(pantern, func(w http.ResponseWriter, req *http.Request) {        //包含某些关键字的不需要鉴权啦        if strings.Contains(req.RequestURI, "/test/") {            fun(w, req)        } else {            //否则判断一下,如果从xxxplatform平台来的不需要鉴权,直接往下走            ticket := req.Header.Get("request-ticket")            clientid := req.Header.Get("request-clientid")            platform := req.Header.Get("request-platform")            if platform != "xxxplatform" {                fun(w, req)                return            }            //否则这要鉴权，通过就直接往下走            if userService.Authorization(ticket, clientid) {                fun(w, req)            } else {                //没通过返回木有权限。                util.RespFail(w, "没有权限")            }        }    })    fmt.Printf("register patern %s ==> %s", pantern, pantern)}

8.6 提升路由性能

我主要在 Router 函数上下功夫，一种可用的设计是利用携程，如下

func Router(pantern string, fun func(w http.ResponseWriter, req *http.Request)) {    http.HandleFunc(pantern, func(w http.ResponseWriter, req *http.Request) {    //先copy出来    var bodyBytes []byte    if c.Request.Body != nil {        bodyBytes, _ = ioutil.ReadAll(req.Body)    }    // 把刚刚读出来的再写进去    req.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))    //这样就可以利用携程干事情啦    go fun(w, req)        })}

需要注意的是要先把数据 copy 出来，然后才能利用携程，否则 fun 函数里面取出的数据是空的。

其他及源代码获取

session、日志，可以引用第三方包。 鉴权可以参考拦截器。 安全，防 xss 攻击可以参考拦截器。 代码获取在公众号回复：golang框架