手把手教你用Golang封装一款适合自己使用的Web

手把手教你用Golang封装一款适合自己使用的Web编程框架

下文章来源于非正式解决方案，作者winlion

非正式解决方案

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

MVC 应用一般结构

目录结构说明如下

名称内容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.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_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"}}
<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 攻击可以参考拦截器。代码获取在公众号回复：golang框架

标题：了解如何使用 Spring MVC 和 Thymeleaf 创建网页（来源：Spring中国教育管理中心）

本指南将引导您完成使用 Spring 创建“Hello, World”网站的过程。

你将建造什么

您将构建一个具有静态主页并且还将接受 HTTP GET 请求的应用程序：http://localhost:8080/greeting。

它将响应一个显示 HTML 的网页。HTML 的正文将包含一个问候语：“Hello, World!”

name您可以使用查询字符串中的可选参数自定义问候语。该 URL 可能是http://localhost:8080/greeting?name=User.

name参数值覆盖默认值，并通过World内容更改为“Hello，User！”反映在响应中

你需要什么

约15分钟
最喜欢的文本编辑器或 IDE
JDK 1.8或更高版本
Gradle 4+或Maven 3.2+
您还可以将代码直接导入 IDE：

弹簧工具套件 (STS)
IntelliJ IDEA

如何完成本指南

像大多数 Spring入门指南一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。无论哪种方式，您最终都会得到工作代码。

要从头开始，请继续从 Spring Initializr 开始。

要跳过基础知识，请执行以下操作：

下载并解压缩本指南的源存储库，或使用Git克隆它：git clone https://github.com/spring-guides/gs-serving-web-content.git
光盘进入gs-serving-web-content/initial
跳转到创建 Web 控制器。

完成后，您可以对照中的代码检查结果gs-serving-web-content/complete。

从 Spring Initializr 开始

您可以使用这个预先初始化的项目并单击 Generate 下载 ZIP 文件。此项目配置为适合本教程中的示例。

手动初始化项目：

导航到https://start.spring.io。该服务提取应用程序所需的所有依赖项，并为您完成大部分设置。
选择 Gradle 或 Maven 以及您要使用的语言。本指南假定您选择了 Java。
单击Dependencies并选择Spring Web、Thymeleaf和Spring Boot DevTools。
单击生成。
下载生成的 ZIP 文件，该文件是根据您的选择配置的 Web 应用程序的存档。

如果您的 IDE 具有 Spring Initializr 集成，您可以从您的 IDE 完成此过程。
你也可以从 Github 上 fork 项目并在你的 IDE 或其他编辑器中打开它。

创建 Web 控制器

在 Spring 构建网站的方法中，HTTP 请求由控制器处理。@Controller您可以通过注释轻松识别控制器。在以下示例中，通过返回 a 的名称（在本例中GreetingController为）来处理 GET 请求。A负责呈现 HTML 内容。以下清单（来自）显示了控制器：/greetingViewgreetingViewsrc/main/java/com/example/servingwebcontent/GreetingController.java

package com.example.servingwebcontent;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class GreetingController {

	@GetMapping("/greeting")
	public String greeting(@RequestParam(name="name", required=false, defaultValue="World") String name, Model model) {
		model.addAttribute("name", name);
		return "greeting";
	}

}复制

这个控制器简洁明了，但是有很多事情要做。我们一步一步分解。

@GetMapping注释确保 HTTP GET 请求/greeting映射到greeting()方法。

@RequestParam将查询字符串参数的值绑定name到方法的name参数中greeting()。此查询字符串参数不是required。如果请求中不存在，则使用defaultValueof World。参数的值name被添加到Model对象中，最终使视图模板可以访问它。

方法体的实现依赖于视图技术（在本例中为Thymeleaf）来执行 HTML 的服务器端呈现。Thymeleaf 解析greeting.html模板并评估th:text表达式以呈现${name}在控制器中设置的参数值。以下清单（来自src/main/resources/templates/greeting.html）显示了greeting.html模板：

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head> 
    <title>Getting Started: Serving Web Content</title> 
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

确保你的类路径上有 Thymeleaf（工件坐标：）org.springframework.boot:spring-boot-starter-thymeleaf。它已经存在于 Github 的“初始”和“完整”示例中。

Spring Boot 开发工具

开发 Web 应用程序的一个常见功能是编写更改代码、重新启动应用程序并刷新浏览器以查看更改。整个过程会消耗大量时间。为了加快这个刷新周期，Spring Boot 提供了一个方便的模块，称为spring-boot-devtools。Spring Boot 开发工具：

启用热插拔。
切换模板引擎以禁用缓存。
启用 LiveReload 以自动刷新浏览器。
基于开发而不是生产的其他合理默认值。

运行应用程序

Spring Initializr 为您创建了一个应用程序类。在这种情况下，您不需要进一步修改 Spring Initializr 提供的类。以下清单（来自src/main/java/com/example/servingwebcontent/ServingWebContentApplication.java）显示了应用程序类：

package com.example.servingwebcontent;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ServingWebContentApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServingWebContentApplication.class, args);
    }

}复制

@SpringBootApplication是一个方便的注释，它添加了以下所有内容：

@Configuration: 将类标记为应用程序上下文的 bean 定义源。
@EnableAutoConfiguration：告诉 Spring Boot 根据类路径设置、其他 bean 和各种属性设置开始添加 bean。例如，如果spring-webmvc位于类路径上，则此注释将应用程序标记为 Web 应用程序并激活关键行为，例如设置DispatcherServlet.
@ComponentScan: 告诉 Spring 在包中查找其他组件、配置和服务com/example，让它找到控制器。

该main()方法使用 Spring Boot 的SpringApplication.run()方法来启动应用程序。您是否注意到没有一行 XML？也没有web.xml文件。这个 Web 应用程序是 100% 纯 Java，您不必处理任何管道或基础设施的配置。

构建一个可执行的 JAR

您可以使用 Gradle 或 Maven 从命令行运行应用程序。您还可以构建一个包含所有必要依赖项、类和资源的单个可执行 JAR 文件并运行它。构建可执行 jar 可以在整个开发生命周期、跨不同环境等中轻松地将服务作为应用程序交付、版本化和部署。

如果您使用 Gradle，则可以使用./gradlew bootRun. 或者，您可以使用构建 JAR 文件./gradlew build，然后运行 ?JAR 文件，如下所示：

java -jar build/libs/gs-serving-web-content-0.1.0.jar

如果您使用 Maven，则可以使用./mvnw spring-boot:run. 或者，您可以使用构建 JAR 文件，./mvnw clean package然后运行该 JAR 文件，如下所示：

java -jar 目标/gs-serving-web-content-0.1.0.jar

此处描述的步骤创建了一个可运行的 JAR。您还可以构建经典的 WAR 文件。

显示记录输出。应用程序应在几秒钟内启动并运行。

测试应用程序

现在网站正在运行，请访问http://localhost:8080/greeting，您应该会看到“Hello, World!”。

通过访问提供name查询字符串参数http://localhost:8080/greeting?name=User。注意消息是如何从“Hello, World!”改变的。到“你好，用户！”：

这一变化表明，@RequestParam安排在GreetingController按预期工作。该name参数已被赋予默认值World，但可以通过查询字符串显式覆盖它。

添加主页

静态资源，包括 HTML、JavaScript 和 CSS，可以通过将它们放到源代码中的正确位置从 Spring Boot 应用程序提供。默认情况下，Spring Boot 从位于/static(或/public) 的类路径中的资源中提供静态内容。该index.html资源是特殊的，因为如果它存在，它会被用作“欢迎页面” "serving-web-content/ which means it is served up as the root resource (that is, at `http://localhost:8080/）。因此，您需要创建以下文件（您可以在中找到该文件src/main/resources/static/index.html）：

<!DOCTYPE HTML>
<html>
<head> 
    <title>Getting Started: Serving Web Content</title> 
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p>Get your greeting <a href="/greeting">here</a></p>
</body>
</html>复制

重新启动应用程序时，您将看到 HTML 位于http://localhost:8080/.

概括

恭喜！您刚刚使用 Spring 开发了一个网页。

#程序员#

.MVC视图

　　在Web开发的MVC和Razor中，都有使用视图，在Razor中称为"页"。.cshtml视图是嵌入了Razor标记的HTML模板。 Razor 标记使用C#代码，用于与HTML 标记交互以生成发送给客户端的网页。在MVC目录结构中，Views / [ControllerName] 文件夹下用于创建视图，其中Views/Shared 文件夹下的视图是控制器共享的视图。

　　1.1 视图页Razor 标记

　　　　下面是Views/Home 文件夹中创建一个 About.cshtml 文件，呈现的视图如下：

@{
    ViewData["Title"]="About";
}
<h2>@ViewData["Title"].</h2>
<h3>@ViewData["Message"]</h3>

　　　　Razor 标记以 @ 符号开头。后面的大括号 { ... } 括住的是 Razor 代码块，是运行 C# 语句。只需用 @ 符号来引用值，即可在 HTML 中显示这些值。比如上面h2和h3标签。

　　1.2 控制器指定视图

　　　　通常以 ViewResult 的形式从Action返回结果到视图，这是一种 ActionResult结果类型（Web api中有讲到)。但通常不会这样做。因为大多数控制器均继承自Controller，因此只需使用 View 方法即可返回 ViewResult。示例如下：

public IActionResult About()
{
    ViewData["Message"]="Your application description page.";
    
    return View();
}

　　　　View 方法有多个重载。可选择指定：

    //要返回的显式视图
    return View("Orders");
    //要传递给视图的模型(实体)对象
    return View(Orders);
    //视图和模型
    return View("Orders", Orders);

　　1.3 视图发现

　　　　Action返回一个视图时, 这个过程叫“视图发现”。默认的 return View(); 将返回与当前Action方法同名的视图。搜索匹配的视图文件顺序规则如下：

        Views/[ControllerName]/[ViewName].cshtml
        Views/Shared/[ViewName].cshtml

　　　　当return View()时，首先在 Views/[ControllerName] 文件夹中搜索该视图。如果在此处找不到匹配的视图，则会在“Shared”文件夹中搜索该视图。

　　　　在返回视图时，可以提供视图文件路径。如果使用绝对路径(“/”或“~/”开头)，必须指定 .cshtml 扩展名：

    　　return View("Views/Home/About.cshtml");

　　　　也可使用相对路径在不同目录中指定视图，而无需指定 .cshtml 扩展名：

       return View("../Manage/Index");

　　　　可以用“./”前缀来指示当前的控制器特定目录：

       return View("./About");

　　1.4 向视图传递数据

　　　　可以使用多种方法将数据传递给视图。包括：(1)强类型数据：viewmodel。(2)弱类型数据ViewData (ViewDataAttribute)、ViewBag。ViewBag 在 Razor 页中不可用。

　　　　(1) 强类型数据 viewmodel

　　　　　　在传递数据到视图中，最可靠的是使用强类型数据，因为编译时能检查并且有智能感知。在视图页中使用@model指令来指定模型（可以是实体或集合泛型实体）。如下所示，其中前端的WebApplication1.ViewModels.Address是实体类命令空间，通过后端返回view强类型映射：

@model WebApplication1.ViewModels.Address
<h2>Contact</h2>
<address>
    @Model.Street<br>
    @Model.City, @Model.State @Model.PostalCode<br>
    <abbr title="Phone">P:</abbr> 425.555.0100
</address>

public IActionResult Contact()
{
    ViewData["Message"]="Your contact page.";

    var viewModel=new Address()
    {
        Name="Microsoft",
        Street="One Microsoft Way",
        City="Redmond",
        State="WA",
        PostalCode="98052-6399"
    };

    //返回强类型
    return View(viewModel);
}

　　(2) 弱类型数据（ViewData、ViewData 属性和 ViewBag)

　　　　视图还可以访问弱类型（也称为松散类型）的数据集合。可以使用弱类型数据集合将少量数据传入及传出控制器和视图。ViewData 属性是弱类型对象的字典。ViewBag 属性是 ViewData 的包装器，为基础 ViewData 集合提供动态属性。ViewData派生自 ViewDataDictionary，ViewBag派生自 DynamicViewData。

　　　　ViewData 和 ViewBag 在运行时进行动态解析。由于它们不提供编译时类型检查，因此使用这两者通常比使用 viewmodel 更容易出错。建议尽量减少或根本不使用 ViewData 和 ViewBag。

　　　　ViewData介绍

　　　　　　下面是一个ViewData存储对象，在视图上强制转换为特定类型(Address)。

public IActionResult SomeAction()
{
    ViewData["Greeting"]="Hello";
    ViewData["Address"]=new Address()
    {
        Name="Steve",
        Street="123 Main St",
        City="Hudson",
        State="OH",
        PostalCode="44236"
    };

    return View();
}

@{
    // Since Address isn't a string, it requires a cast.
    var address=ViewData["Address"] as Address;
}

@ViewData["Greeting"] World!

<address>
    @address.Name<br>
    @address.Street<br>
    @address.City, @address.State @address.PostalCode
</address>

　　　　ViewData 特性介绍

　　　　　　可以在控制器或 Razor 页面模型上，使用 [ViewData] 修饰属性。下面是一个示例：

public class HomeController : Controller
{
    [ViewData]
    public string Title { get; set; }

    public IActionResult About()
    {
        Title="About Us";
        ViewData["Message"]="Your application description page.";

        return View();
    }
}

//通过字典key取出
<title>@ViewData["Title"] - WebApplication</title>

　　　　ViewBag介绍

　　　　　　ViewBag 不需要强制转换，因此使用起来更加方便。下面示例如下：　　　

public IActionResult SomeAction()
{
   // Greeting不需要先声明，Address 也一样,因为是Dynamic类型
    ViewBag.Greeting="Hello";
    ViewBag.Address=new Address()
    {
        Name="Steve",
        Street="123 Main St",
        City="Hudson",
        State="OH",
        PostalCode="44236"
    };

    return View();
}

@ViewBag.Greeting World!

<address>
    @ViewBag.Address.Name<br>
    @ViewBag.Address.Street<br>
    @ViewBag.Address.City, @ViewBag.Address.State @ViewBag.Address.PostalCode
</address>

　　　　更多视图功能包括：标记帮助程序、服务注入视图，视图组件等

在线咨询

上一篇：java项目：统计图表怎么做？百度echarts使用
下一篇：用HTML5的canvas来画一个梦幻星空，来学习一

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商