手把手教你用Golang封装一款适合自己使用的Web编程框架(函数定义参数初始化模板)

非正式解决方案

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

目录结构说明如下

名称内容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 := <-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，每次调用的时候会从配置中获取，因此只需要重新加载数据即可。

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

//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 定义在同一个文件中，便于阅读。

实体和表结构对应，一定要定义 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)层配置

如下几点需要注意

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

{{define "demo/index"}}<div>Hello,Modal</div>{{end}}

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

http://localhost/demo/index5.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\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/index5.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 } } }

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

应用场景是在每个页面中都需要使用 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 xxx5.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"}}<div>Hello,Modal ,hello func retutn {{hello}}Hello,Modal ,hello2 func retutn {{hello2 "参数2"}}</div>{{end}}

返回结果

Hello,Modal ,hello func retutn helloHello,Modal ,hello func retutn hello2参数25.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)

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

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 (pPageArg) GetPageSize() int{ if p.Pagesize==0{ return 100 }else{ return p.Pagesize }}//获得分页当前第几页func (pPageArg) GetPageFrom() int{ if p.Pagefrom<0{ return 0 }else{ return p.Pagefrom }}//获得排序 ID DESC ，前端传递参数 desc=排序字段 或者asc=排序字段func (pPageArg) 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-admin6.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 <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符合某一条件的记录数目

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

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

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

数据库建议使用 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(5time.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\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 攻击可以参考拦截器。
代码获取在公众号回复：golang框架