为了账号安全,请及时绑定邮箱和手机立即绑定

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

2019.05.25 08:51 812浏览



最近开了一节课,《支持10万人同时在线 Go语言打造高并发web即时聊天(IM)应用

https://img2.mukewang.com/5ce890400001051714480650.jpg

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

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

MVC 应用一般结构,

https://img3.mukewang.com/5ce88f130001677906040574.jpg

目录结构说明如下

名称内容
model模型层目录,类比Java 中的entity
view视图层,存放所有templete模板
ctrl控制器层, 存放全部控制器
service服务层,类比Java里面的service
html一些静态资源页面
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.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 添加数据注入

应用场景是在每个页面中都需要使用 session 中的用户 ID 数据。方法是在 RegisterPage 函数内部模板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

}

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

名称内容
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.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 函数里面取出的数据是空的。

其他及源代码获取

session、日志,可以引用第三方包。 鉴权可以参考拦截器。 安全,防 xss 攻击可以参考拦截器。 代码获取加微信公众号 betaidea


点击查看更多内容
Go

本文原创发布于慕课网 ,转载请注明出处,谢谢合作

5人点赞

若觉得本文不错,就分享一下吧!

评论

相关文章推荐

正在加载中
意见反馈 邀请有奖 帮助中心 APP下载
官方微信

举报

0/150
提交
取消