这本书的内容基本上是我学习Go过程以及以前从事Web开发过程中的一些经验总结，里面部分内容参考了很多站点的内容，感谢这些站点的内容让我能够总结出来这本书，参考资料如下： 1. [golang blog](http://blog.golang.org/) 2. [Russ Cox blog](http://research.swtch.com/) 3. [go book](http://go-book.appsp0t.com/) 4. [golangtutorials](http://golangtutorials.blogspot.com/) 5. [轩脉刃de刀光剑影](http://www.cnblogs.com/yjf512/) 6. [Go 官网文档](http://golang.org/doc/) 7. [Network programming with Go](http://jan.newmarch.name/go/) 8. [setup-the-rails-application-for-internationalization](http://guides.rubyonrails.org/i18n.html#setup-the-rails-application-for-internationalization) 9. [The Cross-Site Scripting (XSS) FAQ](http://www.cgisecurity.com/xss-faq.html) 10. [Network programming with Go](http://jan.newmarch.name/go)

这一章主要阐述了如何基于beego框架进行扩展，这包括静态文件的支持，静态文件主要讲述了如何利用beego进行快速的网站开发，利用bootstrap搭建漂亮的站点；第二小结讲解了如何在beego中集成sessionManager，方便用户在利用beego的时候快速的使用session；第三小结介绍了表单和验证，基于Go语言的struct的定义使得我们在开发Web的过程中从重复的工作中解放出来，而且加入了验证之后可以尽量做到数据安全，第四小结介绍了用户认证，用户认证主要有三方面的需求，http basic和http digest认证，第三方认证，自定义认证，通过代码演示了如何利用现有的第三方包集成到beego应用中来实现这些认证；第五小节介绍了多语言的支持，beego中集成了go-i18n这个多语言包，用户可以很方便的利用该库开发多语言的Web应用；第六小节介绍了如何集成Go的pprof包，pprof包是用于性能调试的工具，通过对beego的改造之后集成了pprof包，使得用户可以利用pprof测试基于beego开发的应用，通过这六个小节的介绍我们扩展出来了一个比较强壮的beego框架，这个框架足以应付目前大多数的Web应用，用户可以继续发挥自己的想象力去扩展，我这里只是简单的介绍了我能想的到的几个比较重要的扩展。

Go语言有一个非常棒的设计就是标准库里面带有代码的性能监控工具，在两个地方有包： ~~~ net/http/pprof runtime/pprof ~~~ 其实net/http/pprof中只是使用runtime/pprof包来进行封装了一下，并在http端口上暴露出来 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.6.md#beego支持pprof)beego支持pprof 目前beego框架新增了pprof，该特性默认是不开启的，如果你需要测试性能，查看相应的执行goroutine之类的信息，其实Go的默认包"net/http/pprof"已经具有该功能，如果按照Go默认的方式执行Web，默认就可以使用，但是由于beego重新封装了ServHTTP函数，默认的包是无法开启该功能的，所以需要对beego的内部改造支持pprof。 * 首先在beego.Run函数中根据变量是否自动加载性能包 ~~~ if PprofOn { BeeApp.RegisterController(`/debug/pprof`, &ProfController{}) BeeApp.RegisterController(`/debug/pprof/:pp([\w]+)`, &ProfController{}) } ~~~ * 设计ProfConterller ~~~ package beego import ( "net/http/pprof" ) type ProfController struct { Controller } func (this *ProfController) Get() { switch this.Ctx.Params[":pp"] { default: pprof.Index(this.Ctx.ResponseWriter, this.Ctx.Request) case "": pprof.Index(this.Ctx.ResponseWriter, this.Ctx.Request) case "cmdline": pprof.Cmdline(this.Ctx.ResponseWriter, this.Ctx.Request) case "profile": pprof.Profile(this.Ctx.ResponseWriter, this.Ctx.Request) case "symbol": pprof.Symbol(this.Ctx.ResponseWriter, this.Ctx.Request) } this.Ctx.ResponseWriter.WriteHeader(200) } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.6.md#使用入门)使用入门 通过上面的设计，你可以通过如下代码开启pprof： ~~~ beego.PprofOn = true ~~~ 然后你就可以在浏览器中打开如下URL就看到如下界面： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.6.pprof.png?raw=true) 图14.7 系统当前goroutine、heap、thread信息 点击goroutine我们可以看到很多详细的信息： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.6.pprof2.png?raw=true) 图14.8 显示当前goroutine的详细信息 我们还可以通过命令行获取更多详细的信息 ~~~ go tool pprof http://localhost:8080/debug/pprof/profile ~~~ 这时候程序就会进入30秒的profile收集时间，在这段时间内拼命刷新浏览器上的页面，尽量让cpu占用性能产生数据。 ~~~ (pprof) top10 Total: 3 samples 1 33.3% 33.3% 1 33.3% MHeap_AllocLocked 1 33.3% 66.7% 1 33.3% os/exec.(*Cmd).closeDescriptors 1 33.3% 100.0% 1 33.3% runtime.sigprocmask 0 0.0% 100.0% 1 33.3% MCentral_Grow 0 0.0% 100.0% 2 66.7% main.Compile 0 0.0% 100.0% 2 66.7% main.compile 0 0.0% 100.0% 2 66.7% main.run 0 0.0% 100.0% 1 33.3% makeslice1 0 0.0% 100.0% 2 66.7% net/http.(*ServeMux).ServeHTTP 0 0.0% 100.0% 2 66.7% net/http.(*conn).serve (pprof)web ~~~ [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.6.pprof3.png?raw=true) 图14.9 展示的执行流程信息

我们在第十章介绍过国际化和本地化，开发了一个go-i18n库，这小节我们将把该库集成到beego框架里面来，使得我们的框架支持国际化和本地化。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.5.md#i18n集成)i18n集成 beego中设置全局变量如下： ~~~ Translation i18n.IL Lang string //设置语言包，zh、en LangPath string //设置语言包所在位置 ~~~ 初始化多语言函数: ~~~ func InitLang(){ beego.Translation:=i18n.NewLocale() beego.Translation.LoadPath(beego.LangPath) beego.Translation.SetLocale(beego.Lang) } ~~~ 为了方便在模板中直接调用多语言包，我们设计了三个函数来处理响应的多语言： ~~~ beegoTplFuncMap["Trans"] = i18n.I18nT beegoTplFuncMap["TransDate"] = i18n.I18nTimeDate beegoTplFuncMap["TransMoney"] = i18n.I18nMoney func I18nT(args ...interface{}) string { ok := false var s string if len(args) == 1 { s, ok = args[0].(string) } if !ok { s = fmt.Sprint(args...) } return beego.Translation.Translate(s) } func I18nTimeDate(args ...interface{}) string { ok := false var s string if len(args) == 1 { s, ok = args[0].(string) } if !ok { s = fmt.Sprint(args...) } return beego.Translation.Time(s) } func I18nMoney(args ...interface{}) string { ok := false var s string if len(args) == 1 { s, ok = args[0].(string) } if !ok { s = fmt.Sprint(args...) } return beego.Translation.Money(s) } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.5.md#多语言开发使用)多语言开发使用 1. 设置语言以及语言包所在位置，然后初始化i18n对象： ~~~ beego.Lang = "zh" beego.LangPath = "views/lang" beego.InitLang() ~~~ 2. 设计多语言包 上面讲了如何初始化多语言包，现在设计多语言包，多语言包是json文件，如第十章介绍的一样，我们需要把设计的文件放在LangPath下面，例如zh.json或者en.json ~~~ # zh.json { "zh": { "submit": "提交", "create": "创建" } } #en.json { "en": { "submit": "Submit", "create": "Create" } } ~~~ 3. 使用语言包 我们可以在controller中调用翻译获取响应的翻译语言，如下所示： ~~~ func (this *MainController) Get() { this.Data["create"] = beego.Translation.Translate("create") this.TplNames = "index.tpl" } ~~~ 我们也可以在模板中直接调用响应的翻译函数： ~~~ //直接文本翻译 {{.create | Trans}} //时间翻译 {{.time | TransDate}} //货币翻译 {{.money | TransMoney}} ~~~

在开发Web应用过程中，用户认证是开发者经常遇到的问题，用户登录、注册、登出等操作，而一般认证也分为三个方面的认证 * HTTP Basic和 HTTP Digest认证 * 第三方集成认证：QQ、微博、豆瓣、OPENID、google、github、facebook和twitter等 * 自定义的用户登录、注册、登出，一般都是基于session、cookie认证 beego目前没有针对这三种方式进行任何形式的集成，但是可以充分的利用第三方开源库来实现上面的三种方式的用户认证，不过后续beego会对前面两种认证逐步集成。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.4.md#http-basic和-http-digest认证)HTTP Basic和 HTTP Digest认证 这两个认证是一些应用采用的比较简单的认证，目前已经有开源的第三方库支持这两个认证： ~~~ github.com/abbot/go-http-auth ~~~ 下面代码演示了如何把这个库引入beego中从而实现认证： ~~~ package controllers import ( "github.com/abbot/go-http-auth" "github.com/astaxie/beego" ) func Secret(user, realm string) string { if user == "john" { // password is "hello" return "$1$dlPL2MqE$oQmn16q49SqdmhenQuNgs1" } return "" } type MainController struct { beego.Controller } func (this *MainController) Prepare() { a := auth.NewBasicAuthenticator("example.com", Secret) if username := a.CheckAuth(this.Ctx.Request); username == "" { a.RequireAuth(this.Ctx.ResponseWriter, this.Ctx.Request) } } func (this *MainController) Get() { this.Data["Username"] = "astaxie" this.Data["Email"] = "astaxie@gmail.com" this.TplNames = "index.tpl" } ~~~ 上面代码利用了beego的prepare函数，在执行正常逻辑之前调用了认证函数，这样就非常简单的实现了http auth，digest的认证也是同样的原理。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.4.md#oauth和oauth2的认证)oauth和oauth2的认证 oauth和oauth2是目前比较流行的两种认证方式，还好第三方有一个库实现了这个认证，但是是国外实现的，并没有QQ、微博之类的国内应用认证集成： ~~~ github.com/bradrydzewski/go.auth ~~~ 下面代码演示了如何把该库引入beego中从而实现oauth的认证，这里以github为例演示： 1. 添加两条路由 ~~~ beego.RegisterController("/auth/login", &controllers.GithubController{}) beego.RegisterController("/mainpage", &controllers.PageController{}) ~~~ 2. 然后我们处理GithubController登陆的页面： ~~~ package controllers import ( "github.com/astaxie/beego" "github.com/bradrydzewski/go.auth" ) const ( githubClientKey = "a0864ea791ce7e7bd0df" githubSecretKey = "a0ec09a647a688a64a28f6190b5a0d2705df56ca" ) type GithubController struct { beego.Controller } func (this *GithubController) Get() { // set the auth parameters auth.Config.CookieSecret = []byte("7H9xiimk2QdTdYI7rDddfJeV") auth.Config.LoginSuccessRedirect = "/mainpage" auth.Config.CookieSecure = false githubHandler := auth.Github(githubClientKey, githubSecretKey) githubHandler.ServeHTTP(this.Ctx.ResponseWriter, this.Ctx.Request) } ~~~ 3. 处理登陆成功之后的页面 ~~~ package controllers import ( "github.com/astaxie/beego" "github.com/bradrydzewski/go.auth" "net/http" "net/url" ) type PageController struct { beego.Controller } func (this *PageController) Get() { // set the auth parameters auth.Config.CookieSecret = []byte("7H9xiimk2QdTdYI7rDddfJeV") auth.Config.LoginSuccessRedirect = "/mainpage" auth.Config.CookieSecure = false user, err := auth.GetUserCookie(this.Ctx.Request) //if no active user session then authorize user if err != nil || user.Id() == "" { http.Redirect(this.Ctx.ResponseWriter, this.Ctx.Request, auth.Config.LoginRedirect, http.StatusSeeOther) return } //else, add the user to the URL and continue this.Ctx.Request.URL.User = url.User(user.Id()) this.Data["pic"] = user.Picture() this.Data["id"] = user.Id() this.Data["name"] = user.Name() this.TplNames = "home.tpl" } ~~~ 整个的流程如下，首先打开浏览器输入地址： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.4.github.png?raw=true) 图14.4 显示带有登录按钮的首页 然后点击链接出现如下界面： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.4.github2.png?raw=true) 图14.5 点击登录按钮后显示github的授权页 然后点击Authorize app就出现如下界面： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.4.github3.png?raw=true) 图14.6 授权登录之后显示的获取到的github信息页 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.4.md#自定义认证)自定义认证 自定义的认证一般都是和session结合验证的，如下代码来源于一个基于beego的开源博客： ~~~ //登陆处理 func (this *LoginController) Post() { this.TplNames = "login.tpl" this.Ctx.Request.ParseForm() username := this.Ctx.Request.Form.Get("username") password := this.Ctx.Request.Form.Get("password") md5Password := md5.New() io.WriteString(md5Password, password) buffer := bytes.NewBuffer(nil) fmt.Fprintf(buffer, "%x", md5Password.Sum(nil)) newPass := buffer.String() now := time.Now().Format("2006-01-02 15:04:05") userInfo := models.GetUserInfo(username) if userInfo.Password == newPass { var users models.User users.Last_logintime = now models.UpdateUserInfo(users) //登录成功设置session sess := globalSessions.SessionStart(this.Ctx.ResponseWriter, this.Ctx.Request) sess.Set("uid", userInfo.Id) sess.Set("uname", userInfo.Username) this.Ctx.Redirect(302, "/") } } //注册处理 func (this *RegController) Post() { this.TplNames = "reg.tpl" this.Ctx.Request.ParseForm() username := this.Ctx.Request.Form.Get("username") password := this.Ctx.Request.Form.Get("password") usererr := checkUsername(username) fmt.Println(usererr) if usererr == false { this.Data["UsernameErr"] = "Username error, Please to again" return } passerr := checkPassword(password) if passerr == false { this.Data["PasswordErr"] = "Password error, Please to again" return } md5Password := md5.New() io.WriteString(md5Password, password) buffer := bytes.NewBuffer(nil) fmt.Fprintf(buffer, "%x", md5Password.Sum(nil)) newPass := buffer.String() now := time.Now().Format("2006-01-02 15:04:05") userInfo := models.GetUserInfo(username) if userInfo.Username == "" { var users models.User users.Username = username users.Password = newPass users.Created = now users.Last_logintime = now models.AddUser(users) //登录成功设置session sess := globalSessions.SessionStart(this.Ctx.ResponseWriter, this.Ctx.Request) sess.Set("uid", userInfo.Id) sess.Set("uname", userInfo.Username) this.Ctx.Redirect(302, "/") } else { this.Data["UsernameErr"] = "User already exists" } } func checkPassword(password string) (b bool) { if ok, _ := regexp.MatchString("^[a-zA-Z0-9]{4,16}$", password); !ok { return false } return true } func checkUsername(username string) (b bool) { if ok, _ := regexp.MatchString("^[a-zA-Z0-9]{4,16}$", username); !ok { return false } return true } ~~~ 有了用户登陆和注册之后，其他模块的地方可以增加如下这样的用户是否登陆的判断： ~~~ func (this *AddBlogController) Prepare() { sess := globalSessions.SessionStart(this.Ctx.ResponseWriter, this.Ctx.Request) sess_uid := sess.Get("userid") sess_username := sess.Get("username") if sess_uid == nil { this.Ctx.Redirect(302, "/admin/login") return } this.Data["Username"] = sess_username } ~~~

在Web开发中对于这样的一个流程可能很眼熟： * 打开一个网页显示出表单。 * 用户填写并提交了表单。 * 如果用户提交了一些无效的信息，或者可能漏掉了一个必填项，表单将会连同用户的数据和错误问题的描述信息返回。 * 用户再次填写，继续上一步过程，直到提交了一个有效的表单。 在接收端，脚本必须： * 检查用户递交的表单数据。 * 验证数据是否为正确的类型，合适的标准。例如，如果一个用户名被提交，它必须被验证是否只包含了允许的字符。它必须有一个最小长度，不能超过最大长度。用户名不能与已存在的他人用户名重复，甚至是一个保留字等。 * 过滤数据并清理不安全字符，保证逻辑处理中接收的数据是安全的。 * 如果需要，预格式化数据（数据需要清除空白或者经过HTML编码等等。） * 准备好数据，插入数据库。 尽管上面的过程并不是很复杂，但是通常情况下需要编写很多代码，而且为了显示错误信息，在网页中经常要使用多种不同的控制结构。创建表单验证虽简单，实施起来实在枯燥无味。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.3.md#表单和验证)表单和验证 对于开发者来说，一般开发过程都是相当复杂，而且大多是在重复一样的工作。假设一个场景项目中忽然需要增加一个表单数据，那么局部代码的整个流程都需要修改。我们知道Go里面struct是常用的一个数据结构，因此beego的form采用了struct来处理表单信息。 首先定义一个开发Web应用时相对应的struct，一个字段对应一个form元素，通过struct的tag来定义相应的元素信息和验证信息，如下所示： ~~~ type User struct{ Username string `form:text,valid:required` Nickname string `form:text,valid:required` Age int `form:text,valid:required|numeric` Email string `form:text,valid:required|valid_email` Introduce string `form:textarea` } ~~~ 定义好struct之后接下来在controller中这样操作 ~~~ func (this *AddController) Get() { this.Data["form"] = beego.Form(&User{}) this.Layout = "admin/layout.html" this.TplNames = "admin/add.tpl" } ~~~ 在模板中这样显示表单 ~~~ <h1>New Blog Post</h1> <form action="" method="post"> {{.form.render()}} </form> ~~~ 上面我们定义好了整个的第一步，从struct到显示表单的过程，接下来就是用户填写信息，服务器端接收数据然后验证，最后插入数据库。 ~~~ func (this *AddController) Post() { var user User form := this.GetInput(&user) if !form.Validates() { return } models.UserInsert(&user) this.Ctx.Redirect(302, "/admin/index") } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.3.md#表单类型)表单类型 以下列表列出来了对应的form元素信息： | 名称 | 参数 | 功能描述 | |-----|------|--------| | **text** | No | textbox输入框 | | **button** | No | 按钮 | | **checkbox** | No | 多选择框 | | **dropdown** | No | 下拉选择框 | | **file** | No | 文件上传 | | **hidden** | No | 隐藏元素 | | **password** | No | 密码输入框 | | **radio** | No | 单选框 | | **textarea** | No | 文本输入框 | ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.3.md#表单验证)表单验证 以下列表将列出可被使用的原生规则 | 规则 | 参数 | 描述 | 举例 | |-----|------|--------|--------| | **required** | No | 如果元素为空，则返回FALSE | | **matches** | Yes | 如果表单元素的值与参数中对应的表单字段的值不相等，则返回FALSE | matches[form_item] | | **is_unique** | Yes | 如果表单元素的值与指定数据表栏位有重复，则返回False（译者注：比如is_unique[User.Email]，那么验证类会去查找User表中Email栏位有没有与表单元素一样的值，如存重复，则返回false，这样开发者就不必另写Callback验证代码。） | is_unique[table.field] | | **min_length** | Yes | 如果表单元素值的字符长度少于参数中定义的数字，则返回FALSE | min_length[6] | | **max_length** | Yes | 如果表单元素值的字符长度大于参数中定义的数字，则返回FALSE | max_length[12] | | **exact_length** | Yes | 如果表单元素值的字符长度与参数中定义的数字不符，则返回FALSE | exact_length[8] | | **greater_than** | Yes | 如果表单元素值是非数字类型，或小于参数定义的值，则返回FALSE | greater_than[8] | | **less_than** | Yes | 如果表单元素值是非数字类型，或大于参数定义的值，则返回FALSE | less_than[8] | | **alpha** | No | 如果表单元素值中包含除字母以外的其他字符，则返回FALSE || | **alpha_numeric** | No | 如果表单元素值中包含除字母和数字以外的其他字符，则返回FALSE || | **alpha_dash** | No | 如果表单元素值中包含除字母/数字/下划线/破折号以外的其他字符，则返回FALSE || | **numeric** | No | 如果表单元素值中包含除数字以外的字符，则返回 FALSE || | **integer** | No | 如果表单元素中包含除整数以外的字符，则返回FALSE || | **decimal** | Yes | 如果表单元素中输入（非小数）不完整的值，则返回FALSE || | **is_natural** | No | 如果表单元素值中包含了非自然数的其他数值 （其他数值不包括零），则返回FALSE。自然数形如：0,1,2,3....等等。 || | **is_natural_no_zero** | No | 如果表单元素值包含了非自然数的其他数值 （其他数值包括零），则返回FALSE。非零的自然数：1,2,3.....等等。 || | **valid_email** | No | 如果表单元素值包含不合法的email地址，则返回FALSE || | **valid_emails** | No | 如果表单元素值中任何一个值包含不合法的email地址（地址之间用英文逗号分割），则返回FALSE。 || | **valid_ip** | No | 如果表单元素的值不是一个合法的IP地址，则返回FALSE。 || | **valid_base64** | No | 如果表单元素的值包含除了base64 编码字符之外的其他字符，则返回FALSE。 ||

第六章的时候我们介绍过如何在Go语言中使用session，也实现了一个sessionManger，beego框架基于sessionManager实现了方便的session处理功能。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.2.md#session集成)session集成 beego中主要有以下的全局变量来控制session处理： ~~~ //related to session SessionOn bool // 是否开启session模块，默认不开启 SessionProvider string // session后端提供处理模块，默认是sessionManager支持的memory SessionName string // 客户端保存的cookies的名称 SessionGCMaxLifetime int64 // cookies有效期 GlobalSessions *session.Manager //全局session控制器 ~~~ 当然上面这些变量需要初始化值，也可以按照下面的代码来配合配置文件以设置这些值： ~~~ if ar, err := AppConfig.Bool("sessionon"); err != nil { SessionOn = false } else { SessionOn = ar } if ar := AppConfig.String("sessionprovider"); ar == "" { SessionProvider = "memory" } else { SessionProvider = ar } if ar := AppConfig.String("sessionname"); ar == "" { SessionName = "beegosessionID" } else { SessionName = ar } if ar, err := AppConfig.Int("sessiongcmaxlifetime"); err != nil && ar != 0 { int64val, _ := strconv.ParseInt(strconv.Itoa(ar), 10, 64) SessionGCMaxLifetime = int64val } else { SessionGCMaxLifetime = 3600 } ~~~ 在beego.Run函数中增加如下代码： ~~~ if SessionOn { GlobalSessions, _ = session.NewManager(SessionProvider, SessionName, SessionGCMaxLifetime) go GlobalSessions.GC() } ~~~ 这样只要SessionOn设置为true，那么就会默认开启session功能，独立开一个goroutine来处理session。 为了方便我们在自定义Controller中快速使用session，作者在`beego.Controller`中提供了如下方法： ~~~ func (c *Controller) StartSession() (sess session.Session) { sess = GlobalSessions.SessionStart(c.Ctx.ResponseWriter, c.Ctx.Request) return } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.2.md#session使用)session使用 通过上面的代码我们可以看到，beego框架简单地继承了session功能，那么在项目中如何使用呢？ 首先我们需要在应用的main入口处开启session： ~~~ beego.SessionOn = true ~~~ 然后我们就可以在控制器的相应方法中如下所示的使用session了： ~~~ func (this *MainController) Get() { var intcount int sess := this.StartSession() count := sess.Get("count") if count == nil { intcount = 0 } else { intcount = count.(int) } intcount = intcount + 1 sess.Set("count", intcount) this.Data["Username"] = "astaxie" this.Data["Email"] = "astaxie@gmail.com" this.Data["Count"] = intcount this.TplNames = "index.tpl" } ~~~ 上面的代码展示了如何在控制逻辑中使用session，主要分两个步骤： 1. 获取session对象 ~~~ //获取对象,类似PHP中的session_start() sess := this.StartSession() ~~~ 2. 使用session进行一般的session值操作 ~~~ //获取session值，类似PHP中的$_SESSION["count"] sess.Get("count") //设置session值 sess.Set("count", intcount) ~~~ 从上面代码可以看出基于beego框架开发的应用中使用session相当方便，基本上和PHP中调用`session_start()`类似。

我们在前面已经讲过如何处理静态文件，这小节我们详细的介绍如何在beego里面设置和使用静态文件。通过再介绍一个twitter开源的html、css框架bootstrap，无需大量的设计工作就能够让你快速地建立一个漂亮的站点。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.1.md#beego静态文件实现和设置)beego静态文件实现和设置 Go的net/http包中提供了静态文件的服务，`ServeFile`和`FileServer`等函数。beego的静态文件处理就是基于这一层处理的，具体的实现如下所示： ~~~ //static file server for prefix, staticDir := range StaticDir { if strings.HasPrefix(r.URL.Path, prefix) { file := staticDir + r.URL.Path[len(prefix):] http.ServeFile(w, r, file) w.started = true return } } ~~~ StaticDir里面保存的是相应的url对应到静态文件所在的目录，因此在处理URL请求的时候只需要判断对应的请求地址是否包含静态处理开头的url，如果包含的话就采用http.ServeFile提供服务。 举例如下： ~~~ beego.StaticDir["/asset"] = "/static" ~~~ 那么请求url如`http://www.beego.me/asset/bootstrap.css`就会请求`/static/bootstrap.css`来提供反馈给客户端。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.1.md#bootstrap集成)bootstrap集成 Bootstrap是Twitter推出的一个开源的用于前端开发的工具包。对于开发者来说，Bootstrap是快速开发Web应用程序的最佳前端工具包。它是一个CSS和HTML的集合，它使用了最新的HTML5标准，给你的Web开发提供了时尚的版式，表单，按钮，表格，网格系统等等。 * 组件 　　Bootstrap中包含了丰富的Web组件，根据这些组件，可以快速的搭建一个漂亮、功能完备的网站。其中包括以下组件： 　　下拉菜单、按钮组、按钮下拉菜单、导航、导航条、面包屑、分页、排版、缩略图、警告对话框、进度条、媒体对象等 * Javascript插件 　　Bootstrap自带了13个jQuery插件，这些插件为Bootstrap中的组件赋予了“生命”。其中包括： 　　模式对话框、标签页、滚动条、弹出框等。 * 定制自己的框架代码 　　可以对Bootstrap中所有的CSS变量进行修改，依据自己的需求裁剪代码。 [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.1.bootstrap.png?raw=true) 图14.1 bootstrap站点 接下来我们利用bootstrap集成到beego框架里面来，快速的建立一个漂亮的站点。 1. 首先把下载的bootstrap目录放到我们的项目目录，取名为static，如下截图所示 [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.1.bootstrap2.png?raw=true) 图14.2 项目中静态文件目录结构 2. 因为beego默认设置了StaticDir的值，所以如果你的静态文件目录是static的话就无须再增加了： StaticDir["/static"] = "static" 3. 模板中使用如下的地址就可以了： ~~~ //css文件 <link href="/static/css/bootstrap.css" rel="stylesheet"> //js文件 <script src="/static/js/bootstrap-transition.js"></script> //图片文件 <img src="/static/img/logo.png"> ~~~ 上面可以实现把bootstrap集成到beego中来，如下展示的图就是集成进来之后的展现效果图： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/14.1.bootstrap3.png?raw=true) 图14.3 构建的基于bootstrap的站点界面 这些模板和格式bootstrap官方都有提供，这边就不再重复贴代码，大家可以上bootstrap官方网站学习如何编写模板。

第十三章介绍了如何开发一个Web框架，通过介绍MVC、路由、日志处理、配置处理完成了一个基本的框架系统，但是一个好的框架需要一些方便的辅助工具来快速的开发Web，那么我们这一章将就如何提供一些快速开发Web的工具进行介绍，第一小节介绍如何处理静态文件，如何利用现有的twitter开源的bootstrap进行快速的开发美观的站点，第二小节介绍如何利用前面介绍的session来进行用户登录处理，第三小节介绍如何方便的输出表单、这些表单如何进行数据验证，如何快速的结合model进行数据的增删改操作，第四小节介绍如何进行一些用户认证，包括http basic认证、http digest认证，第五小节介绍如何利用前面介绍的i18n支持多语言的应用开发。第六小节介绍了如何集成Go的pprof包用于性能调试。 通过本章的扩展，beego框架将具有快速开发Web的特性，最后我们将讲解如何利用这些扩展的特性扩展开发第十三章开发的博客系统，通过开发一个完整、美观的博客系统让读者了解beego开发带给你的快速。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/14.0.md#目录)目录 

这一章我们主要介绍了如何实现一个基础的Go语言框架，框架包含有路由设计，由于Go内置的http包中路由的一些不足点，我们设计了动态路由规则，然后介绍了MVC模式中的Controller设计，controller实现了REST的实现，这个主要思路来源于tornado框架，然后设计实现了模板的layout以及自动化渲染等技术，主要采用了Go内置的模板引擎，最后我们介绍了一些辅助的日志、配置等信息的设计，通过这些设计我们实现了一个基础的框架beego，目前该框架已经开源在github，最后我们通过beego实现了一个博客系统，通过实例代码详细的展现了如何快速的开发一个站点。

前面介绍了beego框架实现的整体构思以及部分实现的伪代码，这小节介绍通过beego建立一个博客系统，包括博客浏览、添加、修改、删除等操作。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.5.md#博客目录)博客目录 博客目录如下所示： ~~~ . ├── 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 ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.5.md#博客路由)博客路由 博客主要的路由规则如下所示： ~~~ //显示博客首页 beego.Router("/", &controllers.IndexController{}) //查看博客详细信息 beego.Router("/view/:id([0-9]+)", &controllers.ViewController{}) //新建博客博文 beego.Router("/new", &controllers.NewController{}) //删除博文 beego.Router("/delete/:id([0-9]+)", &controllers.DeleteController{}) //编辑博文 beego.Router("/edit/:id([0-9]+)", &controllers.EditController{}) ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.5.md#数据库结构)数据库结构 数据库设计最简单的博客信息 ~~~ CREATE TABLE entries ( id INT AUTO_INCREMENT, title TEXT, content TEXT, created DATETIME, primary key (id) ); ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.5.md#控制器)控制器 IndexController: ~~~ type IndexController struct { beego.Controller } func (this *IndexController) Get() { this.Data["blogs"] = models.GetAll() this.Layout = "layout.tpl" this.TplNames = "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.TplNames = "view.tpl" } ~~~ NewController ~~~ type NewController struct { beego.Controller } func (this *NewController) Get() { this.Layout = "layout.tpl" this.TplNames = "new.tpl" } func (this *NewController) Post() { inputs := this.Input() var blog models.Blog blog.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.TplNames = "new.tpl" } func (this *EditController) Post() { inputs := this.Input() var blog models.Blog blog.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 := GetBlog(id int) this.Data["Post"] = blog models.DelBlog(blog) this.Ctx.Redirect(302, "/") } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.5.md#model层)model层 ~~~ package models import ( "database/sql" "github.com/astaxie/beedb" _ "github.com/ziutek/mymysql/godrv" "time" ) type Blog struct { Id int `PK` Title string Content string Created 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 } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.5.md#view层)view层 layout.tpl ~~~ <html> <head> <title>My Blog</title> <style> #menu { width: 200px; float: right; } </style> </head> <body> <ul id="menu"> <li><a href="/">Home</a></li> <li><a href="/new">New Post</a></li> </ul> {{.LayoutContent}} </body> </html> ~~~ index.tpl ~~~ <h1>Blog posts</h1> <ul> {{range .blogs}} <li> <a href="/view/{{.Id}}">{{.Title}}</a> from {{.Created}} <a href="/edit/{{.Id}}">Edit</a> <a href="/delete/{{.Id}}">Delete</a> </li> {{end}} </ul> ~~~ view.tpl ~~~ <h1>{{.Post.Title}}</h1> {{.Post.Created}}<br/> {{.Post.Content}} ~~~ new.tpl ~~~ <h1>New Blog Post</h1> <form action="" method="post"> 标题:<input type="text" name="title"><br> 内容：<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"> 标题:<input type="text" name="title" value="{{.Post.Title}}"><br> 内容：<textarea name="content" colspan="3" rowspan="10">{{.Post.Content}}</textarea> <input type="hidden" name="id" value="{{.Post.Id}}"> <input type="submit"> </form> ~~~

## 日志和配置的重要性 前面已经介绍过日志在我们程序开发中起着很重要的作用，通过日志我们可以记录调试我们的信息，当初介绍过一个日志系统seelog，根据不同的level输出不同的日志，这个对于程序开发和程序部署来说至关重要。我们可以在程序开发中设置level低一点，部署的时候把level设置高，这样我们开发中的调试信息可以屏蔽掉。 配置模块对于应用部署牵涉到服务器不同的一些配置信息非常有用，例如一些数据库配置信息、监听端口、监听地址等都是可以通过配置文件来配置，这样我们的应用程序就具有很强的灵活性，可以通过配置文件的配置部署在不同的机器上，可以连接不同的数据库之类的。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.4.md#beego的日志设计)beego的日志设计 beego的日志设计部署思路来自于seelog，根据不同的level来记录日志，但是beego设计的日志系统比较轻量级，采用了系统的log.Logger接口，默认输出到os.Stdout,用户可以实现这个接口然后通过beego.SetLogger设置自定义的输出，详细的实现如下所示： ~~~ // Log levels to control the logging output. const ( LevelTrace = iota LevelDebug LevelInfo LevelWarning LevelError LevelCritical ) // logLevel controls the global log level used by the logger. var level = LevelTrace // LogLevel returns the global log level and can be used in // own implementations of the logger interface. func Level() int { return level } // SetLogLevel sets the global log level used by the simple // logger. func SetLevel(l int) { level = l } ~~~ 上面这一段实现了日志系统的日志分级，默认的级别是Trace，用户通过SetLevel可以设置不同的分级。 ~~~ // logger references the used application logger. var BeeLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime) // SetLogger sets a new logger. func SetLogger(l *log.Logger) { BeeLogger = l } // Trace logs a message at trace level. func Trace(v ...interface{}) { if level <= LevelTrace { BeeLogger.Printf("[T] %v\n", v) } } // Debug logs a message at debug level. func Debug(v ...interface{}) { if level <= LevelDebug { BeeLogger.Printf("[D] %v\n", v) } } // Info logs a message at info level. func Info(v ...interface{}) { if level <= LevelInfo { BeeLogger.Printf("[I] %v\n", v) } } // Warning logs a message at warning level. func Warn(v ...interface{}) { if level <= LevelWarning { BeeLogger.Printf("[W] %v\n", v) } } // Error logs a message at error level. func Error(v ...interface{}) { if level <= LevelError { BeeLogger.Printf("[E] %v\n", v) } } // Critical logs a message at critical level. func Critical(v ...interface{}) { if level <= LevelCritical { BeeLogger.Printf("[C] %v\n", v) } } ~~~ 上面这一段代码默认初始化了一个BeeLogger对象，默认输出到os.Stdout，用户可以通过beego.SetLogger来设置实现了logger的接口输出。这里面实现了六个函数： * Trace（一般的记录信息，举例如下：） * "Entered parse function validation block" * "Validation: entered second 'if'" * "Dictionary 'Dict' is empty. Using default value" * Debug（调试信息，举例如下：） * "Web page requested: [http://somesite.com](http://somesite.com/) Params='...'" * "Response generated. Response size: 10000\. Sending." * "New file received. Type:PNG Size:20000" * Info（打印信息，举例如下：） * "Web server restarted" * "Hourly statistics: Requested pages: 12345 Errors: 123 ..." * "Service paused. Waiting for 'resume' call" * Warn（警告信息，举例如下：） * "Cache corrupted for file='test.file'. Reading from back-end" * "Database 192.168.0.7/DB not responding. Using backup 192.168.0.8/DB" * "No response from statistics server. Statistics not sent" * Error（错误信息，举例如下：） * "Internal error. Cannot process request #12345 Error:...." * "Cannot perform login: credentials DB not responding" * Critical（致命错误，举例如下：） * "Critical panic received: .... Shutting down" * "Fatal error: ... App is shutting down to prevent data corruption or loss" 可以看到每个函数里面都有对level的判断，所以如果我们在部署的时候设置了level=LevelWarning，那么Trace、Debug、Info这三个函数都不会有任何的输出，以此类推。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.4.md#beego的配置设计)beego的配置设计 配置信息的解析，beego实现了一个key=value的配置文件读取，类似ini配置文件的格式，就是一个文件解析的过程，然后把解析的数据保存到map中，最后在调用的时候通过几个string、int之类的函数调用返回相应的值，具体的实现请看下面： 首先定义了一些ini配置文件的一些全局性常量 ： ~~~ var ( bComment = []byte{'#'} bEmpty = []byte{} bEqual = []byte{'='} bDQuote = []byte{'"'} ) ~~~ 定义了配置文件的格式： ~~~ // A Config represents the configuration. type Config struct { filename string comment map[int][]string // id: []{comment, key...}; id 1 is for main comment. data map[string]string // key: value offset map[string]int64 // key: offset; for editing. sync.RWMutex } ~~~ 定义了解析文件的函数，解析文件的过程是打开文件，然后一行一行的读取，解析注释、空行和key=value数据： ~~~ // ParseFile creates a new Config and parses the file configuration from the // named file. 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() var comment bytes.Buffer buf := bufio.NewReader(file) for nComment, off := 0, int64(1); ; { line, _, err := buf.ReadLine() if err == io.EOF { break } if bytes.Equal(line, bEmpty) { continue } off += int64(len(line)) if bytes.HasPrefix(line, bComment) { line = bytes.TrimLeft(line, "#") line = bytes.TrimLeftFunc(line, unicode.IsSpace) comment.Write(line) comment.WriteByte('\n') continue } if comment.Len() != 0 { cfg.comment[nComment] = []string{comment.String()} comment.Reset() nComment++ } val := bytes.SplitN(line, bEqual, 2) if bytes.HasPrefix(val[1], bDQuote) { val[1] = bytes.Trim(val[1], `"`) } key := strings.TrimSpace(string(val[0])) cfg.comment[nComment-1] = append(cfg.comment[nComment-1], key) cfg.data[key] = strings.TrimSpace(string(val[1])) cfg.offset[key] = off } return cfg, nil } ~~~ 下面实现了一些读取配置文件的函数，返回的值确定为bool、int、float64或string： ~~~ // Bool returns the boolean value for a given key. func (c *Config) Bool(key string) (bool, error) { return strconv.ParseBool(c.data[key]) } // Int returns the integer value for a given key. func (c *Config) Int(key string) (int, error) { return strconv.Atoi(c.data[key]) } // Float returns the float value for a given key. func (c *Config) Float(key string) (float64, error) { return strconv.ParseFloat(c.data[key], 64) } // String returns the string value for a given key. func (c *Config) String(key string) string { return c.data[key] } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.4.md#应用指南)应用指南 下面这个函数是我一个应用中的例子，用来获取远程url地址的json数据，实现如下： ~~~ func GetJson() { resp, err := http.Get(beego.AppConfig.String("url")) if err != nil { beego.Critical("http get info error") return } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) err = json.Unmarshal(body, &AllInfo) if err != nil { beego.Critical("error:", err) } } ~~~ 函数中调用了框架的日志函数`beego.Critical`函数用来报错，调用了`beego.AppConfig.String("url")`用来获取配置文件中的信息，配置文件的信息如下(app.conf)： ~~~ appname = hs url ="http://www.api.com/api.html" ~~~

传统的MVC框架大多数是基于Action设计的后缀式映射，然而，现在Web流行REST风格的架构。尽管使用Filter或者rewrite能够通过URL重写实现REST风格的URL，但是为什么不直接设计一个全新的REST风格的 MVC框架呢？本小节就是基于这种思路来讲述如何从头设计一个基于REST风格的MVC框架中的controller，最大限度地简化Web应用的开发，甚至编写一行代码就可以实现“Hello, world”。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.3.md#controller作用)controller作用 MVC设计模式是目前Web应用开发中最常见的架构模式，通过分离 Model（模型）、View（视图）和 Controller（控制器），可以更容易实现易于扩展的用户界面(UI)。Model指后台返回的数据；View指需要渲染的页面，通常是模板页面，渲染后的内容通常是HTML；Controller指Web开发人员编写的处理不同URL的控制器，如前面小节讲述的路由就是URL请求转发到控制器的过程，controller在整个的MVC框架中起到了一个核心的作用，负责处理业务逻辑，因此控制器是整个框架中必不可少的一部分，Model和View对于有些业务需求是可以不写的，例如没有数据处理的逻辑处理，没有页面输出的302调整之类的就不需要Model和View，但是controller这一环节是必不可少的。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.3.md#beego的rest设计)beego的REST设计 前面小节介绍了路由实现了注册struct的功能，而struct中实现了REST方式，因此我们需要设计一个用于逻辑处理controller的基类，这里主要设计了两个类型，一个struct、一个interface ~~~ type Controller struct { Ct *Context Tpl *template.Template Data map[interface{}]interface{} ChildName string TplNames string Layout []string TplExt string } type ControllerInterface interface { Init(ct *Context, cn string) //初始化上下文和子类名称 Prepare() //开始执行之前的一些处理 Get() //method=GET的处理 Post() //method=POST的处理 Delete() //method=DELETE的处理 Put() //method=PUT的处理 Head() //method=HEAD的处理 Patch() //method=PATCH的处理 Options() //method=OPTIONS的处理 Finish() //执行完成之后的处理 Render() error //执行完method对应的方法之后渲染页面 } ~~~ 那么前面介绍的路由add函数的时候是定义了ControllerInterface类型，因此，只要我们实现这个接口就可以，所以我们的基类Controller实现如下的方法： ~~~ func (c *Controller) Init(ct *Context, cn string) { c.Data = make(map[interface{}]interface{}) c.Layout = make([]string, 0) c.TplNames = "" c.ChildName = cn c.Ct = ct c.TplExt = "tpl" } func (c *Controller) Prepare() { } func (c *Controller) Finish() { } func (c *Controller) Get() { http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405) } func (c *Controller) Post() { http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405) } func (c *Controller) Delete() { http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405) } func (c *Controller) Put() { http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405) } func (c *Controller) Head() { http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405) } func (c *Controller) Patch() { http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405) } func (c *Controller) Options() { http.Error(c.Ct.ResponseWriter, "Method Not Allowed", 405) } func (c *Controller) Render() error { if len(c.Layout) > 0 { var filenames []string for _, file := range c.Layout { filenames = append(filenames, path.Join(ViewsPath, file)) } t, err := template.ParseFiles(filenames...) if err != nil { Trace("template ParseFiles err:", err) } err = t.ExecuteTemplate(c.Ct.ResponseWriter, c.TplNames, c.Data) if err != nil { Trace("template Execute err:", err) } } else { if c.TplNames == "" { c.TplNames = c.ChildName + "/" + c.Ct.Request.Method + "." + c.TplExt } t, err := template.ParseFiles(path.Join(ViewsPath, c.TplNames)) if err != nil { Trace("template ParseFiles err:", err) } err = t.Execute(c.Ct.ResponseWriter, c.Data) if err != nil { Trace("template Execute err:", err) } } return nil } func (c *Controller) Redirect(url string, code int) { c.Ct.Redirect(code, url) } ~~~ 上面的controller基类已经实现了接口定义的函数，通过路由根据url执行相应的controller的原则，会依次执行如下： ~~~ Init() 初始化 Prepare() 执行之前的初始化，每个继承的子类可以来实现该函数 method() 根据不同的method执行不同的函数：GET、POST、PUT、HEAD等，子类来实现这些函数，如果没实现，那么默认都是403 Render() 可选，根据全局变量AutoRender来判断是否执行 Finish() 执行完之后执行的操作，每个继承的子类可以来实现该函数 ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.3.md#应用指南)应用指南 上面beego框架中完成了controller基类的设计，那么我们在我们的应用中可以这样来设计我们的方法： ~~~ package controllers import ( "github.com/astaxie/beego" ) type MainController struct { beego.Controller } func (this *MainController) Get() { this.Data["Username"] = "astaxie" this.Data["Email"] = "astaxie@gmail.com" this.TplNames = "index.tpl" } ~~~ 上面的方式我们实现了子类MainController，实现了Get方法，那么如果用户通过其他的方式(POST/HEAD等)来访问该资源都将返回403，而如果是Get来访问，因为我们设置了AutoRender=true，那么在执行完Get方法之后会自动执行Render函数，就会显示如下界面： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/13.4.beego.png?raw=true) index.tpl的代码如下所示，我们可以看到数据的设置和显示都是相当的简单方便： ~~~ <!DOCTYPE html> <html> <head> <title>beego welcome template</title> </head> <body> <h1>Hello, world!{{.Username}},{{.Email}}</h1> </body> </html> ~~~

## HTTP路由 HTTP路由组件负责将HTTP请求交到对应的函数处理(或者是一个struct的方法)，如前面小节所描述的结构图，路由在框架中相当于一个事件处理器，而这个事件包括： * 用户请求的路径(path)(例如:/user/123,/article/123)，当然还有查询串信息(例如?id=11) * HTTP的请求方法(method)(GET、POST、PUT、DELETE、PATCH等) 路由器就是根据用户请求的事件信息转发到相应的处理函数(控制层)。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.2.md#默认的路由实现)默认的路由实现 在3.4小节有过介绍Go的http包的详解，里面介绍了Go的http包如何设计和实现路由，这里继续以一个例子来说明： ~~~ func fooHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path)) } http.HandleFunc("/foo", fooHandler) http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path)) }) log.Fatal(http.ListenAndServe(":8080", nil)) ~~~ 上面的例子调用了http默认的DefaultServeMux来添加路由，需要提供两个参数，第一个参数是希望用户访问此资源的URL路径(保存在r.URL.Path)，第二参数是即将要执行的函数，以提供用户访问的资源。路由的思路主要集中在两点： * 添加路由信息 * 根据用户请求转发到要执行的函数 Go默认的路由添加是通过函数`http.Handle`和`http.HandleFunc`等来添加，底层都是调用了`DefaultServeMux.Handle(pattern string, handler Handler)`,这个函数会把路由信息存储在一个map信息中`map[string]muxEntry`，这就解决了上面说的第一点。 Go监听端口，然后接收到tcp连接会扔给Handler来处理，上面的例子默认nil即为`http.DefaultServeMux`，通过`DefaultServeMux.ServeHTTP`函数来进行调度，遍历之前存储的map路由信息，和用户访问的URL进行匹配，以查询对应注册的处理函数，这样就实现了上面所说的第二点。 ~~~ for k, v := range mux.m { if !pathMatch(k, path) { continue } if h == nil || len(k) > n { n = len(k) h = v.h } } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.2.md#beego框架路由实现)beego框架路由实现 目前几乎所有的Web应用路由实现都是基于http默认的路由器，但是Go自带的路由器有几个限制： * 不支持参数设定，例如/user/:uid 这种泛类型匹配 * 无法很好的支持REST模式，无法限制访问的方法，例如上面的例子中，用户访问/foo，可以用GET、POST、DELETE、HEAD等方式访问 * 一般网站的路由规则太多了，编写繁琐。我前面自己开发了一个API应用，路由规则有三十几条，这种路由多了之后其实可以进一步简化，通过struct的方法进行一种简化 beego框架的路由器基于上面的几点限制考虑设计了一种REST方式的路由实现，路由设计也是基于上面Go默认设计的两点来考虑：存储路由和转发路由 ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.2.md#存储路由)存储路由 针对前面所说的限制点，我们首先要解决参数支持就需要用到正则，第二和第三点我们通过一种变通的方法来解决，REST的方法对应到struct的方法中去，然后路由到struct而不是函数，这样在转发路由的时候就可以根据method来执行不同的方法。 根据上面的思路，我们设计了两个数据类型controllerInfo(保存路径和对应的struct，这里是一个reflect.Type类型)和ControllerRegistor(routers是一个slice用来保存用户添加的路由信息，以及beego框架的应用信息) ~~~ type controllerInfo struct { regex *regexp.Regexp params map[int]string controllerType reflect.Type } type ControllerRegistor struct { routers []*controllerInfo Application *App } ~~~ ControllerRegistor对外的接口函数有 ~~~ func (p *ControllerRegistor) Add(pattern string, c ControllerInterface) ~~~ 详细的实现如下所示： ~~~ func (p *ControllerRegistor) Add(pattern string, c ControllerInterface) { parts := strings.Split(pattern, "/") j := 0 params := make(map[int]string) for i, part := range parts { if strings.HasPrefix(part, ":") { expr := "([^/]+)" //a user may choose to override the defult expression // similar to expressjs: ‘/user/:id([0-9]+)’ if index := strings.Index(part, "("); index != -1 { expr = part[index:] part = part[:index] } params[j] = part parts[i] = expr j++ } } //recreate the url pattern, with parameters replaced //by regular expressions. then compile the regex pattern = strings.Join(parts, "/") regex, regexErr := regexp.Compile(pattern) if regexErr != nil { //TODO add error handling here to avoid panic panic(regexErr) return } //now create the Route t := reflect.Indirect(reflect.ValueOf(c)).Type() route := &controllerInfo{} route.regex = regex route.params = params route.controllerType = t p.routers = append(p.routers, route) } ~~~ ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.2.md#静态路由实现)静态路由实现 上面我们实现的动态路由的实现，Go的http包默认支持静态文件处理FileServer，由于我们实现了自定义的路由器，那么静态文件也需要自己设定，beego的静态文件夹路径保存在全局变量StaticDir中，StaticDir是一个map类型，实现如下： ~~~ func (app *App) SetStaticPath(url string, path string) *App { StaticDir[url] = path return app } ~~~ 应用中设置静态路径可以使用如下方式实现： ~~~ beego.SetStaticPath("/img","/static/img") ~~~ ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.2.md#转发路由)转发路由 转发路由是基于ControllerRegistor里的路由信息来进行转发的，详细的实现如下代码所示： ~~~ // AutoRoute func (p *ControllerRegistor) ServeHTTP(w http.ResponseWriter, r *http.Request) { defer func() { if err := recover(); err != nil { if !RecoverPanic { // go back to panic panic(err) } else { Critical("Handler crashed with error", err) for i := 1; ; i += 1 { _, file, line, ok := runtime.Caller(i) if !ok { break } Critical(file, line) } } } }() var started bool for prefix, staticDir := range StaticDir { if strings.HasPrefix(r.URL.Path, prefix) { file := staticDir + r.URL.Path[len(prefix):] http.ServeFile(w, r, file) started = true return } } requestPath := r.URL.Path //find a matching Route for _, route := range p.routers { //check if Route pattern matches url if !route.regex.MatchString(requestPath) { continue } //get submatches (params) matches := route.regex.FindStringSubmatch(requestPath) //double check that the Route matches the URL pattern. if len(matches[0]) != len(requestPath) { continue } params := make(map[string]string) if len(route.params) > 0 { //add url parameters to the query param map values := r.URL.Query() for i, match := range matches[1:] { values.Add(route.params[i], match) params[route.params[i]] = match } //reassemble query params and add to RawQuery r.URL.RawQuery = url.Values(values).Encode() + "&" + r.URL.RawQuery //r.URL.RawQuery = url.Values(values).Encode() } //Invoke the request handler vc := reflect.New(route.controllerType) 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) method := vc.MethodByName("Prepare") method.Call(in) if r.Method == "GET" { method = vc.MethodByName("Get") method.Call(in) } else if r.Method == "POST" { method = vc.MethodByName("Post") method.Call(in) } else if r.Method == "HEAD" { method = vc.MethodByName("Head") method.Call(in) } else if r.Method == "DELETE" { method = vc.MethodByName("Delete") method.Call(in) } else if r.Method == "PUT" { method = vc.MethodByName("Put") method.Call(in) } else if r.Method == "PATCH" { method = vc.MethodByName("Patch") method.Call(in) } else if r.Method == "OPTIONS" { method = vc.MethodByName("Options") method.Call(in) } if AutoRender { method = vc.MethodByName("Render") method.Call(in) } method = vc.MethodByName("Finish") method.Call(in) started = true break } //if no matches to url, throw a not found exception if started == false { http.NotFound(w, r) } } ~~~ ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.2.md#使用入门)使用入门 基于这样的路由设计之后就可以解决前面所说的三个限制点，使用的方式如下所示： 基本的使用注册路由： ~~~ beego.BeeApp.RegisterController("/", &controllers.MainController{}) ~~~ 参数注册： ~~~ beego.BeeApp.RegisterController("/:param", &controllers.UserController{}) ~~~ 正则匹配： ~~~ beego.BeeApp.RegisterController("/users/:uid([0-9]+)", &controllers.UserController{}) ~~~

做任何事情都需要做好规划，那么我们在开发博客系统之前，同样需要做好项目的规划，如何设置目录结构，如何理解整个项目的流程图，当我们理解了应用的执行过程，那么接下来的设计编码就会变得相对容易了 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.1.md#gopath以及项目设置)gopath以及项目设置 假设指定gopath是文件系统的普通目录名，当然我们可以随便设置一个目录名，然后将其路径存入GOPATH。前面介绍过GOPATH可以是多个目录：在window系统设置环境变量；在linux/MacOS系统只要输入终端命令`export gopath=/home/astaxie/gopath`，但是必须保证gopath这个代码目录下面有三个目录pkg、bin、src。新建项目的源码放在src目录下面，现在暂定我们的博客目录叫做beeblog，下面是在window下的环境变量和目录结构的截图： [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/13.1.gopath.png?raw=true) 图13.1 环境变量GOPATH设置 [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/13.1.gopath2.png?raw=true) 图13.2 工作目录在$gopath/src下 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.1.md#应用程序流程图)应用程序流程图 博客系统是基于模型-视图-控制器这一设计模式的。MVC是一种将应用程序的逻辑层和表现层进行分离的结构方式。在实践中，由于表现层从Go中分离了出来，所以它允许你的网页中只包含很少的脚本。 * 模型 (Model) 代表数据结构。通常来说，模型类将包含取出、插入、更新数据库资料等这些功能。 * 视图 (View) 是展示给用户的信息的结构及样式。一个视图通常是一个网页，但是在Go中，一个视图也可以是一个页面片段，如页头、页尾。它还可以是一个 RSS 页面，或其它类型的“页面”，Go实现的template包已经很好的实现了View层中的部分功能。 * 控制器 (Controller) 是模型、视图以及其他任何处理HTTP请求所必须的资源之间的中介，并生成网页。 下图显示了项目设计中框架的数据流是如何贯穿整个系统: [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/images/13.1.flow.png?raw=true) 图13.3 框架的数据流 1. main.go作为应用入口，初始化一些运行博客所需要的基本资源，配置信息，监听端口。 2. 路由功能检查HTTP请求，根据URL以及method来确定谁(控制层)来处理请求的转发资源。 3. 如果缓存文件存在，它将绕过通常的流程执行，被直接发送给浏览器。 4. 安全检测：应用程序控制器调用之前，HTTP请求和任一用户提交的数据将被过滤。 5. 控制器装载模型、核心库、辅助函数，以及任何处理特定请求所需的其它资源，控制器主要负责处理业务逻辑。 6. 输出视图层中渲染好的即将发送到Web浏览器中的内容。如果开启缓存，视图首先被缓存，将用于以后的常规请求。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.1.md#目录结构)目录结构 根据上面的应用程序流程设计，博客的目录结构设计如下： ~~~ |——main.go 入口文件 |——conf 配置文件和处理模块 |——controllers 控制器入口 |——models 数据库处理模块 |——utils 辅助函数库 |——static 静态文件目录 |——views 视图库 ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.1.md#框架设计)框架设计 为了实现博客的快速搭建，打算基于上面的流程设计开发一个最小化的框架，框架包括路由功能、支持REST的控制器、自动化的模板渲染，日志系统、配置管理等。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/13.1.md#总结)总结 本小节介绍了博客系统从设置GOPATH到目录建立这样的基础信息，也简单介绍了框架结构采用的MVC模式，博客系统中数据流的执行流程，最后通过这些流程设计了博客系统的目录结构，至此，我们基本完成一个框架的搭建，接下来的几个小节我们将会逐个实现。

前面十二章介绍了如何通过Go来开发Web应用，介绍了很多基础知识、开发工具和开发技巧，那么我们这一章通过这些知识来实现一个简易的Web框架。通过Go语言来实现一个完整的框架设计，这框架中主要内容有第一小节介绍的Web框架的结构规划，例如采用MVC模式来进行开发，程序的执行流程设计等内容；第二小节介绍框架的第一个功能：路由，如何让访问的URL映射到相应的处理逻辑；第三小节介绍处理逻辑，如何设计一个公共的controller，对象继承之后处理函数中如何处理response和request；第四小节介绍如何框架的一些辅助功能，例如日志处理、配置信息等；第五小节介绍如何基于Web框架实现一个博客，包括博文的发表、修改、删除、显示列表等操作。 通过这么一个完整的项目例子，我期望能够让读者了解如何开发Web应用，如何搭建自己的目录结构，如何实现路由，如何实现MVC模式等各方面的开发内容。在框架盛行的今天，MVC也不再是神话。经常听到很多程序员讨论哪个框架好，哪个框架不好， 其实框架只是工具，没有好与不好，只有适合与不适合，适合自己的就是最好的，所以教会大家自己动手写框架，那么不同的需求都可以用自己的思路去实现。 ## 目录 

本章讨论了如何部署和维护我们开发的Web应用相关的一些话题。这些内容非常重要，要创建一个能够基于最小维护平滑运行的应用，必须考虑这些问题。 具体而言，本章讨论的内容包括： * 创建一个强健的日志系统，可以在出现问题时记录错误并且通知系统管理员 * 处理运行时可能出现的错误，包括记录日志，并如何友好的显示给用户系统出现了问题 * 处理404错误，告诉用户请求的页面找不到 * 将应用部署到一个生产环境中(包括如何部署更新) * 如何让部署的应用程序具有高可用 * 备份和恢复文件以及数据库 读完本章内容后，对于从头开始开发一个Web应用需要考虑那些问题，你应该已经有了全面的了解。本章内容将有助于你在实际环境中管理前面各章介绍开发的代码。

这小节我们要讨论应用程序管理的另一个方面：生产服务器上数据的备份和恢复。我们经常会遇到生产服务器的网络断了、硬盘坏了、操作系统崩溃、或者数据库不可用了等各种异常情况，所以维护人员需要对生产服务器上的应用和数据做好异地灾备，冷备热备的准备。在接下来的介绍中，讲解了如何备份应用、如何备份/恢复Mysql数据库和redis数据库。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#应用备份)应用备份 在大多数集群环境下，Web应用程序基本不需要备份，因为这个其实就是一个代码副本，我们在本地开发环境中，或者版本控制系统中已经保持这些代码。但是很多时候，一些开发的站点需要用户来上传文件，那么我们需要对这些用户上传的文件进行备份。目前其实有一种合适的做法就是把和网站相关的需要存储的文件存储到云储存，这样即使系统崩溃，只要我们的文件还在云存储上，至少数据不会丢失。 如果我们没有采用云储存的情况下，如何做到网站的备份呢？这里我们介绍一个文件同步工具rsync：rsync能够实现网站的备份，不同系统的文件的同步，如果是windows的话，需要windows版本cwrsync。 ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#rsync安装)rsync安装 rysnc的官方网站：[http://rsync.samba.org/](http://rsync.samba.org/) 可以从上面获取最新版本的源码。当然，因为rsync是一款非常有用的软件，所以很多Linux的发行版本都将它收录在内了。 软件包安装 ~~~ # sudo apt-get install rsync 注：在debian、ubuntu 等在线安装方法； # yum install rsync 注：Fedora、Redhat、CentOS 等在线安装方法； # rpm -ivh rsync 注：Fedora、Redhat、CentOS 等rpm包安装方法； ~~~ 其它Linux发行版，请用相应的软件包管理方法来安装。源码包安装 ~~~ tar xvf rsync-xxx.tar.gz cd rsync-xxx ./configure --prefix=/usr ;make ;make install 注：在用源码包编译安装之前，您得安装gcc等编译工具才行； ~~~ ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#rsync配置)rsync配置 rsync主要有以下三个配置文件rsyncd.conf(主配置文件)、rsyncd.secrets(密码文件)、rsyncd.motd(rysnc服务器信息)。 关于这几个文件的配置大家可以参考官方网站或者其他介绍rsync的网站，下面介绍服务器端和客户端如何开启 * 服务端开启： ~~~ #/usr/bin/rsync --daemon --config=/etc/rsyncd.conf ~~~ --daemon参数方式，是让rsync以服务器模式运行。把rsync加入开机启动 ~~~ echo 'rsync --daemon' >> /etc/rc.d/rc.local ~~~ 设置rsync密码 ~~~ echo '你的用户名:你的密码' > /etc/rsyncd.secrets chmod 600 /etc/rsyncd.secrets ~~~ * 客户端同步： 客户端可以通过如下命令同步服务器上的文件： ~~~ rsync -avzP --delete --password-file=rsyncd.secrets 用户名@192.168.145.5::www /var/rsync/backup ~~~ 这条命令，简要的说明一下几个要点： 1. -avzP是啥，读者可以使用--help查看 2. --delete 是为了比如A上删除了一个文件，同步的时候，B会自动删除相对应的文件 3. --password-file 客户端中/etc/rsyncd.secrets设置的密码，要和服务端的 /etc/rsyncd.secrets 中的密码一样，这样cron运行的时候，就不需要密码了 4. 这条命令中的"用户名"为服务端的 /etc/rsyncd.secrets中的用户名 5. 这条命令中的 192.168.145.5 为服务端的IP地址 6. ::www，注意是2个 : 号，www为服务端的配置文件 /etc/rsyncd.conf 中的[www]，意思是根据服务端上的/etc/rsyncd.conf来同步其中的[www]段内容，一个 : 号的时候，用于不根据配置文件，直接同步指定目录。 为了让同步实时性，可以设置crontab，保持rsync每分钟同步，当然用户也可以根据文件的重要程度设置不同的同步频率。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#mysql备份)MySQL备份 应用数据库目前还是MySQL为主流，目前MySQL的备份有两种方式：热备份和冷备份，热备份目前主要是采用master/slave方式（master/slave方式的同步目前主要用于数据库读写分离，也可以用于热备份数据），关于如何配置这方面的资料，大家可以找到很多。冷备份的话就是数据有一定的延迟，但是可以保证该时间段之前的数据完整，例如有些时候可能我们的误操作引起了数据的丢失，那么master/slave模式是无法找回丢失数据的，但是通过冷备份可以部分恢复数据。 冷备份一般使用shell脚本来实现定时备份数据库，然后通过上面介绍rsync同步非本地机房的一台服务器。 下面这个是定时备份mysql的备份脚本，我们使用了mysqldump程序，这个命令可以把数据库导出到一个文件中。 ~~~ #!/bin/bash # 以下配置信息请自己修改 mysql_user="USER" #MySQL备份用户 mysql_password="PASSWORD" #MySQL备份用户的密码 mysql_host="localhost" mysql_port="3306" mysql_charset="utf8" #MySQL编码 backup_db_arr=("db1" "db2") #要备份的数据库名称，多个用空格分开隔开 如("db1" "db2" "db3") backup_location=/var/www/mysql #备份数据存放位置，末尾请不要带"/",此项可以保持默认，程序会自动创建文件夹 expire_backup_delete="ON" #是否开启过期备份删除 ON为开启 OFF为关闭 expire_days=3 #过期时间天数 默认为三天，此项只有在expire_backup_delete开启时有效 # 本行开始以下不需要修改 backup_time=`date +%Y%m%d%H%M` #定义备份详细时间 backup_Ymd=`date +%Y-%m-%d` #定义备份目录中的年月日时间 backup_3ago=`date -d '3 days ago' +%Y-%m-%d` #3天之前的日期 backup_dir=$backup_location/$backup_Ymd #备份文件夹全路径 welcome_msg="Welcome to use MySQL backup tools!" #欢迎语 # 判断MYSQL是否启动,mysql没有启动则备份退出 mysql_ps=`ps -ef |grep mysql |wc -l` mysql_listen=`netstat -an |grep LISTEN |grep $mysql_port|wc -l` if [ [$mysql_ps == 0] -o [$mysql_listen == 0] ]; then echo "ERROR:MySQL is not running! backup stop!" exit else echo $welcome_msg fi # 连接到mysql数据库，无法连接则备份退出 mysql -h$mysql_host -P$mysql_port -u$mysql_user -p$mysql_password <<end use mysql; select host,user from user where user='root' and host='localhost'; exit end flag=`echo $?` if [ $flag != "0" ]; then echo "ERROR:Can't connect mysql server! backup stop!" exit else echo "MySQL connect ok! Please wait......" # 判断有没有定义备份的数据库，如果定义则开始备份，否则退出备份 if [ "$backup_db_arr" != "" ];then #dbnames=$(cut -d ',' -f1-5 $backup_database) #echo "arr is (${backup_db_arr[@]})" for dbname in ${backup_db_arr[@]} do echo "database $dbname backup start..." `mkdir -p $backup_dir` `mysqldump -h$mysql_host -P$mysql_port -u$mysql_user -p$mysql_password $dbname --default-character-set=$mysql_charset | gzip > $backup_dir/$dbname-$backup_time.sql.gz` flag=`echo $?` if [ $flag == "0" ];then echo "database $dbname success backup to $backup_dir/$dbname-$backup_time.sql.gz" else echo "database $dbname backup fail!" fi done else echo "ERROR:No database to backup! backup stop" exit fi # 如果开启了删除过期备份，则进行删除操作 if [ "$expire_backup_delete" == "ON" -a "$backup_location" != "" ];then #`find $backup_location/ -type d -o -type f -ctime +$expire_days -exec rm -rf {} \;` `find $backup_location/ -type d -mtime +$expire_days | xargs rm -rf` echo "Expired backup data delete complete!" fi echo "All database backup success! Thank you!" exit fi ~~~ 修改shell脚本的属性： ~~~ chmod 600 /root/mysql_backup.sh chmod +x /root/mysql_backup.sh ~~~ 设置好属性之后，把命令加入crontab，我们设置了每天00:00定时自动备份，然后把备份的脚本目录/var/www/mysql设置为rsync同步目录。 ~~~ 00 00 * * * /root/mysql_backup.sh ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#mysql恢复)MySQL恢复 前面介绍MySQL备份分为热备份和冷备份，热备份主要的目的是为了能够实时的恢复，例如应用服务器出现了硬盘故障，那么我们可以通过修改配置文件把数据库的读取和写入改成slave，这样就可以尽量少时间的中断服务。 但是有时候我们需要通过冷备份的SQL来进行数据恢复，既然有了数据库的备份，就可以通过命令导入： ~~~ mysql -u username -p databse < backup.sql ~~~ 可以看到，导出和导入数据库数据都是相当简单，不过如果还需要管理权限，或者其他的一些字符集的设置的话，可能会稍微复杂一些，但是这些都是可以通过一些命令来完成的。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#redis备份)redis备份 redis是目前我们使用最多的NoSQL，它的备份也分为两种：热备份和冷备份，redis也支持master/slave模式，所以我们的热备份可以通过这种方式实现，相应的配置大家可以参考官方的文档配置，相当的简单。我们这里介绍冷备份的方式：redis其实会定时的把内存里面的缓存数据保存到数据库文件里面，我们备份只要备份相应的文件就可以，就是利用前面介绍的rsync备份到非本地机房就可以实现。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#redis恢复)redis恢复 redis的恢复分为热备份恢复和冷备份恢复，热备份恢复的目的和方法同MySQL的恢复一样，只要修改应用的相应的数据库连接即可。 但是有时候我们需要根据冷备份来恢复数据，redis的冷备份恢复其实就是只要把保存的数据库文件copy到redis的工作目录，然后启动redis就可以了，redis在启动的时候会自动加载数据库文件到内存中，启动的速度根据数据库的文件大小来决定。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.4.md#小结)小结 本小节介绍了我们的应用部分的备份和恢复，即如何做好灾备，包括文件的备份、数据库的备份。同时也介绍了使用rsync同步不同系统的文件，MySQL数据库和redis数据库的备份和恢复，希望通过本小节的介绍，能够给作为开发的你对于线上产品的灾备方案提供一个参考方案。

程序开发完毕之后，我们现在要部署Web应用程序了，但是我们如何来部署这些应用程序呢？因为Go程序编译之后是一个可执行文件，编写过C程序的读者一定知道采用daemon就可以完美的实现程序后台持续运行，但是目前Go还无法完美的实现daemon，因此，针对Go的应用程序部署，我们可以利用第三方工具来管理，第三方的工具有很多，例如Supervisord、upstart、daemontools等，这小节我介绍目前自己系统中采用的工具Supervisord。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.3.md#daemon)daemon 目前Go程序还不能实现daemon，详细的见这个Go语言的bug：，大概的意思说很难从现有的使用的线程中fork一个出来，因为没有一种简单的方法来确保所有已经使用的线程的状态一致性问题。 但是我们可以看到很多网上的一些实现daemon的方法，例如下面两种方式： * MarGo的一个实现思路，使用Commond来执行自身的应用，如果真想实现，那么推荐这种方案 ~~~ d := flag.Bool("d", false, "Whether or not to launch in the background(like a daemon)") if *d { cmd := exec.Command(os.Args[0], "-close-fds", "-addr", *addr, "-call", *call, ) serr, err := cmd.StderrPipe() if err != nil { log.Fatalln(err) } err = cmd.Start() if err != nil { log.Fatalln(err) } s, err := ioutil.ReadAll(serr) s = bytes.TrimSpace(s) if bytes.HasPrefix(s, []byte("addr: ")) { fmt.Println(string(s)) cmd.Process.Release() } else { log.Printf("unexpected response from MarGo: `%s` error: `%v`\n", s, err) cmd.Process.Kill() } } ~~~ * 另一种是利用syscall的方案，但是这个方案并不完善： ~~~ package main import ( "log" "os" "syscall" ) func daemon(nochdir, noclose int) int { var ret, ret2 uintptr var err uintptr darwin := syscall.OS == "darwin" // already a daemon if syscall.Getppid() == 1 { return 0 } // fork off the parent process ret, ret2, err = syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0) if err != 0 { return -1 } // failure if ret2 < 0 { os.Exit(-1) } // handle exception for darwin if 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 process s_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 } ~~~ 上面提出了两种实现Go的daemon方案，但是我还是不推荐大家这样去实现，因为官方还没有正式的宣布支持daemon，当然第一种方案目前来看是比较可行的，而且目前开源库skynet也在采用这个方案做daemon。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.3.md#supervisord)Supervisord 上面已经介绍了Go目前是有两种方案来实现他的daemon，但是官方本身还不支持这一块，所以还是建议大家采用第三方成熟工具来管理我们的应用程序，这里我给大家介绍一款目前使用比较广泛的进程管理软件：Supervisord。Supervisord是用Python实现的一款非常实用的进程管理工具。supervisord会帮你把管理的应用程序转成daemon程序，而且可以方便的通过命令开启、关闭、重启等操作，而且它管理的进程一旦崩溃会自动重启，这样就可以保证程序执行中断后的情况下有自我修复的功能。 > 我前面在应用中踩过一个坑，就是因为所有的应用程序都是由Supervisord父进程生出来的，那么当你修改了操作系统的文件描述符之后，别忘记重启Supervisord，光重启下面的应用程序没用。当初我就是系统安装好之后就先装了Supervisord，然后开始部署程序，修改文件描述符，重启程序，以为文件描述符已经是100000了，其实Supervisord这个时候还是默认的1024个，导致他管理的进程所有的描述符也是1024.开放之后压力一上来系统就开始报文件描述符用光了，查了很久才找到这个坑。 ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.3.md#supervisord安装)Supervisord安装 Supervisord可以通过`sudo easy_install supervisor`安装，当然也可以通过Supervisord官网下载后解压并转到源码所在的文件夹下执行`setup.py install`来安装。 * 使用easy_install必须安装setuptools 打开`http://pypi.python.org/pypi/setuptools#files`，根据你系统的python的版本下载相应的文件，然后执行`sh setuptoolsxxxx.egg`，这样就可以使用easy_install命令来安装Supervisord。 ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.3.md#supervisord配置)Supervisord配置 Supervisord默认的配置文件路径为/etc/supervisord.conf，通过文本编辑器修改这个文件，下面是一个示例的配置文件： ~~~ ;/etc/supervisord.conf [unix_http_server] file = /var/run/supervisord.sock chmod = 0777 chown= root:root [inet_http_server] # Web管理界面设定 port=9001 username = admin password = yourpassword [supervisorctl] ; 必须和'unix_http_server'里面的设定匹配 serverurl = unix:///var/run/supervisord.sock [supervisord] logfile=/var/log/supervisord/supervisord.log ; (main log file;default $CWD/supervisord.log) logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB) logfile_backups=10 ; (num of main logfile rotation backups;default 10) loglevel=info ; (log level;default info; others: debug,warn,trace) pidfile=/var/run/supervisord.pid ; (supervisord pidfile;default supervisord.pid) nodaemon=true ; (start in foreground if true;default false) minfds=1024 ; (min. avail startup file descriptors;default 1024) minprocs=200 ; (min. avail process descriptors;default 200) user=root ; (default is current user, required if root) childlogdir=/var/log/supervisord/ ; ('AUTO' child log dir, default $TEMP) [rpcinterface:supervisor] supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface ; 管理的单个进程的配置，可以添加多个program [program:blogdemon] command=/data/blog/blogdemon autostart = true startsecs = 5 user = root redirect_stderr = true stdout_logfile = /var/log/supervisord/blogdemon.log ~~~ ### [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.3.md#supervisord管理)Supervisord管理 Supervisord安装完成后有两个可用的命令行supervisor和supervisorctl，命令使用解释如下： * supervisord，初始启动Supervisord，启动、管理配置中设置的进程。 * supervisorctl stop programxxx，停止某一个进程(programxxx)，programxxx为[program:blogdemon]里配置的值，这个示例就是blogdemon。 * supervisorctl start programxxx，启动某个进程 * supervisorctl restart programxxx，重启某个进程 * supervisorctl stop all，停止全部进程，注：start、restart、stop都不会载入最新的配置文件。 * supervisorctl reload，载入最新的配置文件，并按新的配置启动、管理所有进程。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.3.md#小结)小结 这小节我们介绍了Go如何实现daemon化，但是由于目前Go的daemon实现的不足，需要依靠第三方工具来实现应用程序的daemon管理的方式，所以在这里介绍了一个用python写的进程管理工具Supervisord，通过Supervisord可以很方便的把我们的Go应用程序管理起来。

我们的Web应用一旦上线之后，那么各种错误出现的概率都有，Web应用日常运行中可能出现多种错误，具体如下所示： * 数据库错误：指与访问数据库服务器或数据相关的错误。例如，以下可能出现的一些数据库错误。 * 连接错误：这一类错误可能是数据库服务器网络断开、用户名密码不正确、或者数据库不存在。 * 查询错误：使用的SQL非法导致错误，这样子SQL错误如果程序经过严格的测试应该可以避免。 * 数据错误：数据库中的约束冲突，例如一个唯一字段中插入一条重复主键的值就会报错，但是如果你的应用程序在上线之前经过了严格的测试也是可以避免这类问题。 * 应用运行时错误：这类错误范围很广，涵盖了代码中出现的几乎所有错误。可能的应用错误的情况如下： * 文件系统和权限：应用读取不存在的文件，或者读取没有权限的文件、或者写入一个不允许写入的文件，这些都会导致一个错误。应用读取的文件如果格式不正确也会报错，例如配置文件应该是ini的配置格式，而设置成了json格式就会报错。 * 第三方应用：如果我们的应用程序耦合了其他第三方接口程序，例如应用程序发表文章之后自动调用接发微博的接口，所以这个接口必须正常运行才能完成我们发表一篇文章的功能。 * HTTP错误：这些错误是根据用户的请求出现的错误，最常见的就是404错误。虽然可能会出现很多不同的错误，但其中比较常见的错误还有401未授权错误(需要认证才能访问的资源)、403禁止错误(不允许用户访问的资源)和503错误(程序内部出错)。 * 操作系统出错：这类错误都是由于应用程序上的操作系统出现错误引起的，主要有操作系统的资源被分配完了，导致死机，还有操作系统的磁盘满了，导致无法写入，这样就会引起很多错误。 * 网络出错：指两方面的错误，一方面是用户请求应用程序的时候出现网络断开，这样就导致连接中断，这种错误不会造成应用程序的崩溃，但是会影响用户访问的效果；另一方面是应用程序读取其他网络上的数据，其他网络断开会导致读取失败，这种需要对应用程序做有效的测试，能够避免这类问题出现的情况下程序崩溃。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.2.md#错误处理的目标)错误处理的目标 在实现错误处理之前，我们必须明确错误处理想要达到的目标是什么，错误处理系统应该完成以下工作： * 通知访问用户出现错误了：不论出现的是一个系统错误还是用户错误，用户都应当知道Web应用出了问题，用户的这次请求无法正确的完成了。例如，对于用户的错误请求，我们显示一个统一的错误页面(404.html)。出现系统错误时，我们通过自定义的错误页面显示系统暂时不可用之类的错误页面(error.html)。 * 记录错误：系统出现错误，一般就是我们调用函数的时候返回err不为nil的情况，可以使用前面小节介绍的日志系统记录到日志文件。如果是一些致命错误，则通过邮件通知系统管理员。一般404之类的错误不需要发送邮件，只需要记录到日志系统。 * 回滚当前的请求操作：如果一个用户请求过程中出现了一个服务器错误，那么已完成的操作需要回滚。下面来看一个例子：一个系统将用户递交的表单保存到数据库，并将这个数据递交到一个第三方服务器，但是第三方服务器挂了，这就导致一个错误，那么先前存储到数据库的表单数据应该删除(应告知无效)，而且应该通知用户系统出现错误了。 * 保证现有程序可运行可服务：我们知道没有人能保证程序一定能够一直正常的运行着，万一哪一天程序崩溃了，那么我们就需要记录错误，然后立刻让程序重新运行起来，让程序继续提供服务，然后再通知系统管理员，通过日志等找出问题。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.2.md#如何处理错误)如何处理错误 错误处理其实我们已经在十一章第一小节里面有过介绍如何设计错误处理，这里我们再从一个例子详细的讲解一下，如何来处理不同的错误： * 通知用户出现错误： 通知用户在访问页面的时候我们可以有两种错误：404.html和error.html，下面分别显示了错误页面的源码： ~~~ <html lang="en"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>找不到页面</title> <meta name="viewport" content="width=device-width, initial-scale=1.0"> </head> <body> <div class="container"> <div class="row"> <div class="span10"> <div class="hero-unit"> <h1>404!</h1> <p>{{.ErrorInfo}}</p> </div> </div><!--/span--> </div> </div> </body> </html> ~~~ 另一个源码： ~~~ <html lang="en"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>系统错误页面</title> <meta name="viewport" content="width=device-width, initial-scale=1.0"> </head> <body> <div class="container"> <div class="row"> <div class="span10"> <div class="hero-unit"> <h1>系统暂时不可用!</h1> <p>{{.ErrorInfo}}</p> </div> </div><!--/span--> </div> </div> </body> </html> ~~~ 404的错误处理逻辑，如果是系统的错误也是类似的操作，同时我们看到在： ~~~ func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/" { sayhelloName(w, r) return } NotFound404(w, r) return } func NotFound404(w http.ResponseWriter, r *http.Request) { log.Error("页面找不到") //记录错误日志 t, _ = t.ParseFiles("tmpl/404.html", nil) //解析模板文件 ErrorInfo := "文件找不到" //获取当前用户信息 t.Execute(w, ErrorInfo) //执行模板的merger操作 } func SystemError(w http.ResponseWriter, r *http.Request) { log.Critical("系统错误") //系统错误触发了Critical，那么不仅会记录日志还会发送邮件 t, _ = t.ParseFiles("tmpl/error.html", nil) //解析模板文件 ErrorInfo := "系统暂时不可用" //获取当前用户信息 t.Execute(w, ErrorInfo) //执行模板的merger操作 } ~~~ ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.2.md#如何处理异常)如何处理异常 我们知道在很多其他语言中有try...catch关键词，用来捕获异常情况，但是其实很多错误都是可以预期发生的，而不需要异常处理，应该当做错误来处理，这也是为什么Go语言采用了函数返回错误的设计，这些函数不会panic，例如如果一个文件找不到，os.Open返回一个错误，它不会panic；如果你向一个中断的网络连接写数据，net.Conn系列类型的Write函数返回一个错误，它们不会panic。这些状态在这样的程序里都是可以预期的。你知道这些操作可能会失败，因为设计者已经用返回错误清楚地表明了这一点。这就是上面所讲的可以预期发生的错误。 但是还有一种情况，有一些操作几乎不可能失败，而且在一些特定的情况下也没有办法返回错误，也无法继续执行，这样情况就应该panic。举个例子：如果一个程序计算x[j]，但是j越界了，这部分代码就会导致panic，像这样的一个不可预期严重错误就会引起panic，在默认情况下它会杀掉进程，它允许一个正在运行这部分代码的goroutine从发生错误的panic中恢复运行，发生panic之后，这部分代码后面的函数和代码都不会继续执行，这是Go特意这样设计的，因为要区别于错误和异常，panic其实就是异常处理。如下代码，我们期望通过uid来获取User中的username信息，但是如果uid越界了就会抛出异常，这个时候如果我们没有recover机制，进程就会被杀死，从而导致程序不可服务。因此为了程序的健壮性，在一些地方需要建立recover机制。 ~~~ func GetUser(uid int) (username string) { defer func() { if x := recover(); x != nil { username = "" } }() username = User[uid] return } ~~~ 上面介绍了错误和异常的区别，那么我们在开发程序的时候如何来设计呢？规则很简单：如果你定义的函数有可能失败，它就应该返回一个错误。当我调用其他package的函数时，如果这个函数实现的很好，我不需要担心它会panic，除非有真正的异常情况发生，即使那样也不应该是我去处理它。而panic和recover是针对自己开发package里面实现的逻辑，针对一些特殊情况来设计。 ## [](https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/12.2.md#小结)小结 本小节总结了当我们的Web应用部署之后如何处理各种错误：网络错误、数据库错误、操作系统错误等，当错误发生时，我们的程序如何来正确处理：显示友好的出错界面、回滚操作、记录日志、通知管理员等操作，最后介绍了如何来正确处理错误和异常。一般的程序中错误和异常很容易混淆的，但是在Go中错误和异常是有明显的区分，所以告诉我们在程序设计中处理错误和异常应该遵循怎么样的原则。