把手教你花10分钟封装一款适用自己的golang编程框架

课程播出后，很多同学希望将其中的编程框架进行分享，有鉴于此，笔者整理了一套适用于golang一般项目的编程框架。老规矩，文章末尾给有源代码地址。

这套框架笔者已经使用在数十个项目中了。结构还是比较合理的。

MVC 应用一般结构，

目录结构说明如下

主程序结构

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

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.go
var cfg *goconfig.ConfigFile
var cfgmap map[string]map[string]string = make(map[string]map[string]string)
var filepath string
//解析peiz
func 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 := <-watch.Events:
                {
                    if ev.Op&fsnotify.Write == fsnotify.Write {
                        //监听到文件系统使用加载新东西
                        ReloadAllCfg()
                    }
                    fmt.Println(ev.Op, ev.Name)
                }
            case err := <-watch.Errors:
                {
                    log.Println("error : ", err)
                    return
                }
            }
        }
    }()
}

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_USERROLE_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"}}
<div>
Hello,Modal
</div>
{{end}}

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

http://localhost/demo/index

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

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

//ctrl/base.go
func 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\n", 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 添加数据注入

templete.ExecuteTemplate(w, tplname, nil)

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

前端模板调用代码如下

{{define "demo/index"}}
<div>
Hello,Modal ,User id is {{.Id}}
</div>
{{end}}

返回结果

Hello,Modal ,User id is xxx

5.5 在页面使用函数

在 RegisterPage 方法内定义一个 funMap

//ctrl/funcmap.go
var 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"}}
<div>
Hello,Modal ,hello func retutn  {{hello}}
Hello,Modal ,hello2 func retutn  {{hello2 "参数2"}}
</div>
{{end}}

返回结果

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

5.6 多多使用 templete 方法

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

{{define "demo/memo"}}
{{if eq .Role 1}}
菜单内容1
{{else if eq .Role 2}}
菜单内容2
{{end}}
<script>
GLOB={"ROLE":.Role}
</script>
{{end}}

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

{{define "demo/index"}}
<div>
{{templete "demo/menu"}}
Hello,Modal ,hello func retutn  {{hello}}
Hello,Modal ,hello2 func retutn  {{hello2 "参数2"}}
</div>
{{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.AuthArg
util.Bind(req,&requestdata)

其中 args.AuthArg 对象定义如下

package args

import "../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.go
package util

import (

    "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 service

import (


    "../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 <to ?",arg.Datefrom.String())
    }
    if (arg.Seller>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

}

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

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.go
func 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)
}
//没有找到需要一个默认404
func 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.go

func (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 函数，当没有任何一个匹配对象时候，进入这个函数。

//没有找到需要一个默认404
func 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\n", 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 函数里面取出的数据是空的。

其他及源代码获取

betaidea