整合營銷服務商
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
下文章來源于非正式解決方案 ，作者winlion
非正式解決方案
思考鏈接價值,非正式解決方案,既扯高大上如人工智能、大數據，也關注碼農日常如分布式、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())
}
}使用配置文件開發包，如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"]使用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);
}系統級配置參數 假設修改了會影響整個應用，需要另起服務的我們稱之為系統級配置，修改了參數，往需要進行相應的操作。如修改了數據庫連接地址，需要重置數據庫連接操作。修改了應用服務器端口，則需要重啟應用服務。
用戶級配置參數 如微信公眾號 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"}約定統一使用駝峰式或者下劃線標記。如下，建議使用駝峰式。
#駝峰
NickName string `xorm:"VARCHAR(40)" form:"nickName" json:"nickName"`
#下劃線
NickName string `xorm:"VARCHAR(40)" form:"nick_name" json:"nick_name"`如下幾點需要注意
關聯便于代碼管理和閱讀。模板位置 /view/demo/index.html，模板內容如下。
{{define "demo/index"}}
<div>
Hello,Modal
</div>
{{end}}外部調用方法如下，大家能很自然知道模板文件位置。
http://localhost/demo/index主要是為了程序員生活更美好(早點下班+偷懶)。
//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為什么要添加調試模式支持?因為調試模式狀態下，我們修改來了頁面模板，需要立即看到頁面內容，而不需要重啟應用。核心代碼如下，即在調試模式狀態下，每次請求都重新解析模板。
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 xxx在 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主要使用場景是分角色菜單，用戶
{{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}}控制器層主要處理對外接口
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,
})
}
}所有參數都需要可預期在一個結構體里面。這樣整個系統編程將變得非常簡單。在上 面函數中，通過如下代碼實現參數綁定
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 ""
}
}大體結構如下
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一般封裝一個底層 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,
})
}以訂單管理為例
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符合某一條件的記錄數目
我們可以用類似于如下函數來統一管理查詢條件，該函數輸出參數，輸出一個 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(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
}在每一個 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()
//
}解決思路如下 首先在 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)
})
}首先需要定義默認路由。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"}在如上所示中定義了 notfound 函數，當沒有任何一個匹配對象時候，進入這個函數。
//沒有找到需要一個默認404
func notfound(w http.ResponseWriter, req *http.Request){
w.Write([]byte("404 NOT FOUNT"))
}我們可以在 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)
}我主要在 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！”反映在響應中
像大多數 Spring入門指南一樣，您可以從頭開始并完成每個步驟，也可以繞過您已經熟悉的基本設置步驟。無論哪種方式，您最終都會得到工作代碼。
要從頭開始，請繼續從 Spring Initializr 開始。
要跳過基礎知識，請執行以下操作：
完成后，您可以對照中的代碼檢查結果gs-serving-web-content/complete。
您可以使用這個預先初始化的項目并單擊 Generate 下載 ZIP 文件。此項目配置為適合本教程中的示例。
手動初始化項目：
如果您的 IDE 具有 Spring Initializr 集成，您可以從您的 IDE 完成此過程。
你也可以從 Github 上 fork 項目并在你的 IDE 或其他編輯器中打開它。
在 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 的“初始”和“完整”示例中。
開發 Web 應用程序的一個常見功能是編寫更改代碼、重新啟動應用程序并刷新瀏覽器以查看更改。整個過程會消耗大量時間。為了加快這個刷新周期，Spring Boot 提供了一個方便的模塊，稱為spring-boot-devtools。Spring Boot 開發工具：
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是一個方便的注釋，它添加了以下所有內容：
該main()方法使用 Spring Boot 的SpringApplication.run()方法來啟動應用程序。您是否注意到沒有一行 XML？也沒有web.xml文件。這個 Web 應用程序是 100% 純 Java，您不必處理任何管道或基礎設施的配置。
您可以使用 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 開發了一個網頁。
#程序員#
在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>
更多視圖功能包括：標記幫助程序、服務注入視圖，視圖組件等
*請認真填寫需求信息，我們會在24小時內與您取得聯系。
