Go教程
手把手教你用Golang封装一款适合自己使用的Web编程框架
以下文章来源于非正式解决方案 ，作者winlion
非正式解决方案
思考链接价值,非正式解决方案,既扯高大上如人工智能、大数据，也关注码农日常如分布式、java和golang,每天分享瞎想的东西。
目录结构说明如下
名称内容model模型层目录,类比Java 中的entityview视图层,存放所有templete模板ctrl控制器层, 存放全部控制器service服务层,类比Java里面的servicehtml一些静态资源页面util核心工具包,Md5加密,返回数据封装等asset静态资源目录,存放js/css/image等args封装全部请求参数对象mnt上传文件的存放目录app.dev.conf开发环境配置文件appd.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/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/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&fsnotifyame==fsnotifyame {
log.Println("重命名文件 : ", ev.Name);
}
if ev.Op&fsnotify.Chmod==fsnotify.Chmod {
log.Println("修改权限 : ", ev.Name);
}3.3 区分系统级配置和用户级配置
系统级配置参数 假设修改了会影响整个应用，需要另起服务的我们称之为系统级配置，修改了参数，往需要进行相应的操作。如修改了数据库连接地址，需要重置数据库连接操作。修改了应用服务器端口，则需要重启应用服务。
用户级配置参数 如微信公众号 appsecret，每次调用的时候会从配置中获取，因此只需要重新加载数据即可。
3.4 配置内容缓存
需要将配置文件内容缓存到 map 中。 需要考虑到 map 的并发操作。
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"`
如下几点需要注意
5.1 模板文件和模板名称关联
关联便于代码管理和阅读。本科证书模板位置 /view/demo/index.html，模板内容如下。
{{define "demo/index"}}
Hello,Modal
{{end}}
外部调用方法如下，大家能很自然知道模板文件位置。
localhost/demo/index5.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
", 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)
//
}
外部调用方法如下，大家能很自然知道模板文件位置。
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
}
}
}
由上可见，调试模式效率是非常低的，我们不应该在生产环境采用调试模式。
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 xxx5.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"}}
Hello,Modal ,hello func retutn {{hello}}
Hello,Modal ,hello2 func retutn {{hello2 "参数2"}}
{{end}}
返回结果
Hello,Modal ,hello func retutn hello
Hello,Modal ,hello func retutn hello2参数25.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}}
控制器层主要处理对外接口
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，篇幅太长，大家可以移步
github/winlion/restgo-admin6.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,
})
}7.1 服务层一般结构
以订单管理为例
package service
import (
"../model"
"../args"
"github/go-xorm/xorm"
"log"
"github/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
}
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 reqthod==httpthodPost {
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 reqthod==httpthodGet {
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],_=regexppile(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)
}
客户端请求
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
", 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 攻击可以参考拦截器。
-
MongoDB身份认证机制揭秘！11-23
-
MongoDB教程：从入门到实践详解11-20
-
执行 Google Ads API 查询后返回的是空数组什么原因？-icode9专业技术文章分享11-17
-
google广告数据不同经理账户下的凭证可以获取对方的api数据吗？-icode9专业技术文章分享11-17
-
SendGrid 的 Go 客户端库怎么实现同时向多个邮箱发送邮件？-icode9专业技术文章分享11-15
-
SendGrid 的 Go 客户端库怎么设置header 和 标签tag 呢？-icode9专业技术文章分享11-15
-
Cargo deny安装指路11-12
-
MongoDB项目实战：从入门到初级应用11-02
-
随时随地一键转录，Google Cloud 新模型 Chirp 2 让语音识别更上一层楼11-01
-
Google Cloud动手实验详解：如何在Cloud Run上开发无服务器应用10-25
-
AI ?先驱齐聚 BAAI 2024，发布大规模语言、多模态、具身、生物计算以及 FlagOpen 2.0 等 AI 模型创新成果。10-24
-
goland工具下，如修改一个项目的标准库SDK的版本-icode9专业技术文章分享10-20
-
Go学习：初学者的简单教程10-17
-
Go学习：新手入门完全指南10-17
-
Golang学习：初学者入门教程10-17
