java语言主程序main写法_把手教你花10分钟封装一款适用自己的golang编程框架

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

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

MVC 应用一般结构，

目录结构说明如下名称内容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 :=

{

if ev.Op&fsnotify.Write == fsnotify.Write {

//监听到文件系统使用加载新东西

ReloadAllCfg()

}

fmt.Println(ev.Op, ev.Name)

}

case err :=

{

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_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.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"}}

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

{{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"}}

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参数2

5.6 多多使用 templete 方法

主要使用场景是分角色菜单，用户{{define "demo/memo"}}

{{if eq .Role 1}}

菜单内容1

{{else if eq .Role 2}}

菜单内容2

{{end}}

GLOB={"ROLE":.Role}

{{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.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

}

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)

//

}

具体使用可以参考 Xormfunc (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 里面定义一个 mapPostRouterMap := 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