Merge branch 'master' of https://github.com/astaxie/build-web-application-with-golang into astaxie

.gitignore

@@ -1,9 +0,0 @@
-# Compiled files.
-*.exe
-*.html
-*.ps
-*.eps
-*.pdf
-*.aux
-*.log
-.gitignore

1.1.md

@@ -45,6 +45,11 @@ Go使用[Mercurial][hg]进行版本管理，首先你必须安装了Mercurial，
 
 ## Go标准包安装
 
+Go提供了每个平台打好包的一键安装，这些包默认会安装到如下目录：/usr/local/go (Windows系统：c:\Go)，当然你可以改变他们的安装位置，但是改变之后你必须在你的环境变量中设置如下信息：
+
+	export GOROOT=$HOME/go  
+	export PATH=$PATH:$GOROOT/bin
+
 ### 如何判断自己的操作系统是32位还是64位？
 
 我们接下来的Go安装需要判断操作系统的位数，所以这小节我们先确定自己的系统类型。

1.2.md

@@ -70,6 +70,7 @@ GOPATH允许多个目录，当有多个目录时，请注意分隔符，多个GO
 
 	cd $GOPATH/src
 	mkdir mathapp
+	cd mathapp
 	vim main.go
 
 // `$GOPATH/src/mathapp/main.go`源码：

1.3.md

@@ -35,7 +35,7 @@
 
 ## go clean
 
-  这个命令是用来移除当前源码包里面编译的文件的。这些文件包括
+  这个命令是用来移除当前源码包里面编译生成的文件。这些文件包括
 
 	_obj/            旧的object目录，由Makefiles遗留
 	_test/           旧的test目录，由Makefiles遗留
@@ -48,7 +48,7 @@
 	DIR.test(.exe)   由go test -c产生
 	MAINFILE(.exe)   由go build MAINFILE.go产生
 
-  我一般都是利用这个命令进行清除编译文件，然后github递交源码，在本机测试的时候这些编译文件都是和系统相关的，但是对于源码管理来说没必要
+  我一般都是利用这个命令清除编译文件，然后github递交源码，在本机测试的时候这些编译文件都是和系统相关的，但是对于源码管理来说没必要
 
 ## go fmt
 

1.4.md

@@ -12,7 +12,9 @@
 
   配置好LiteIDE后，可以打开或拖动任何目录到LiteIDE中作为项目，LiteIDE的编译是针对当前编辑文档所属目录来执行相应的go命令，所以编译时要先打开相应的Go文件。LiteIDE仿IDEA界面，支持项目浏览、文件系统，Package浏览、Golang文档检索、类视图、大纲显示等多个工具窗口的切换。
 
-  代码补全需要安装gocode，目前LiteIDE的自动化提示只支持本文件中函数的提示，还没有做到整个项目中函数的提示。
+  代码补全需要安装gocode:
+	
+	go get github.com/nsf/gocode
 
 
 ## Sublime Text
@@ -43,8 +45,8 @@
   2. 接下来安装gocode和MarGo。
    打开终端运行如下代码（需要git）
 
-		go get -u github.com/nsf/gocode
+		go get github.com/nsf/gocode
-		go get -u github.com/DisposaBoy/MarGo
+		go get github.com/DisposaBoy/MarGo
 
   这个时候我们会发现在`$GOPATH/bin`下面多了两个可执行文件，gocode和MarGo，这两个文件会在GoSublime加载时自动启动。
 
@@ -81,7 +83,7 @@ Vim是从vi发展出来的一个文本编辑器, 代码补全、编译及错误
 
 		go get -u github.com/nsf/gocode
 
-	gocode默认安装到`$GOPATH/bin`下面，需要把`$GOPATH/bin`路径设置到系统`$PATH`里面。
+	gocode默认安装到`$GOBIN`下面。
 
  4. 配置[Gocode](https://github.com/nsf/gocode/)
 
@@ -119,7 +121,7 @@ Emacs传说中的神器，她不仅仅是一个编辑器，它是一个整合环
 
 		go get -u github.com/nsf/gocode
 
-	gocode默认安装到`$GOPATH/bin`里面下面，需要把`$GOPATH/bin`路径设置到系统`$PATH`里面。
+	gocode默认安装到`$GOBIN`里面下面。
 
   3. 配置[Gocode](https://github.com/nsf/gocode/)
 

11.3.md

@@ -27,7 +27,6 @@ Go语言中自带有一个轻量级的测试框架`testing`和自带的`go test`
 2. gotest_test.go:这是我们的单元测试文件，但是记住下面的这些原则：
 
 	- 文件名必须是`_test.go`结尾的，这样在执行`go test`的时候才会执行到相应的代码
-	- 包名必须和被测试文件的包名一致，例如上面的包名是gotest，那么test文件的包名也必须是gotest
 	- 你必须import `testing`这个包
 	- 所有的测试用例函数必须是`Test`开头
 	- 测试用例会按照源代码中写的顺序依次执行
@@ -94,14 +93,14 @@ Go语言中自带有一个轻量级的测试框架`testing`和自带的`go test`
 		ok  	gotest	0.013s
 
 ## 如何编写压力测试
-压力测试是用来检测我们写的函数是否有足够好的性能，和写单元功能测试类似，需要注意以下几点：
+压力测试用来检测函数(方法）的性能，和编写单元功能测试的方法类似,此处不再赘述，但需要注意以下几点：
 
-- 压力测试函数必须如下格式，其中`XXX`可以是任意字母数字的组合，但是首字母不能是小写字母
+- 压力测试用例必须遵循如下格式，其中XXX可以是任意字母数字的组合，但是首字母不能是小写字母
 
 		func BenchmarkXXX(b *testing.B) { ... }
 		
 - `go test`不会默认执行压力测试的函数，如果要执行压力测试需要带上参数`-test.bench`，语法:`-test.bench="test_name_regex"`,例如`go test -test.bench=".*"`表示测试全部的压力测试函数
-- 压力测试函数中记得在循环中使用`testing.B.N`从而使得压力测试可以正常的运行
+- 在压力测试用例中,请记得在循环体内使用`testing.B.N`,以使测试可以正常的运行
 - 文件名也必须以`_test.go`结尾
 
 下面我们新建一个压力测试文件webbench_test.go，代码如下所示：
@@ -141,7 +140,7 @@ Go语言中自带有一个轻量级的测试框架`testing`和自带的`go test`
 上面的结果显示我们没有执行任何`TestXXX`的单元测试函数，显示的结果只执行了压力测试函数，第一条显示了`Benchmark_Division`执行了500000000次，每次的执行平均时间是7.76纳秒，第二条显示了`Benchmark_TimeConsumingFunction`执行了500000000，每次的平均执行时间是7.80纳秒。最后一条显示总过的执行时间。
 
 ## 小结
-通过上面对单元测试和压力测试的编写，我们知道Go语言里面的`testing`包虽然轻量，但是编写测试用例和压力测试非常简单，而且使用内置的命令`go test`就可以非常方便的执行这些单元测试和压力测试，这样我们每次修改完函数执行一下单元测试和压力测试，可以简单的做回归测试。
+通过上面对单元测试和压力测试的学习，我们可以看到`testing`包很轻量，编写单元测试和压力测试用例非常简单，配合内置的`go test`命令就可以非常方便的进行测试，这样在我们每次修改完代码,执行一下go test就可以简单的完成回归测试了。
 
 
 ## links

12.1.md

@@ -1,4 +1,164 @@
 # 12.1 应用日志
+我们期望开发的Web应用程序能够把整个程序运行过程中出现的各种事件一一记录下来，Go语言中提供了一个简易的log包，我们使用该包可以方便的实现日志记录的功能，这些日志都是基本的给予fmt包的打印再结合panic之类的一些函数来处理我们一般的打印抛出错误之类的。如果我们想把我们的应用日志保存到文件，然后又能够结合日志实现很多复杂的功能，编写过Java或者C++的读者应该都使用过log4j和log4cpp之类的日志工具，Go目前标准包就如前面介绍的只是包含了一个简单的包，但是目前第三方开发的一个日志系统实现了很强大的日志功能，`https://github.com/cihub/seelog`，接下来我们介绍如何该日志系统来实现我们应用的日志功能。
+
+## seelog介绍
+seelog是用Go语言实现的一个日志系统，它提供了一些简单的函数来实现复杂的日志分配、过滤和格式化。主要有如下特性：
+
+- XML的动态配置，可以不用重新编译程序而动态的加载配置信息
+- 支持热更新，能够动态改变配置而不需要重启应用
+- 支持多输出流，能够同时把日志输出到多种流中、例如文件流、网络流等
+- 支持不同的日志输出
+
+	- 命令行输出
+	- 文件输出
+	- 缓存输出
+	- 支持log rotate
+	- SMTP邮件
+
+上面只列举了部分特性，seelog是一个特别强大的日志处理系统，详细的内容请参看官方wiki。接下来我将简要介绍一下如何在项目中使用它：
+
+首先安装seelog
+
+	go get -u github.com/cihub/seelog
+	
+然后我们来看一个简单的例子：
+
+	package main
+
+	import log "github.com/cihub/seelog"
+
+	func main() {
+	    defer log.Flush()
+	    log.Info("Hello from Seelog!")
+	}
+
+编译后运行如果出现了`Hello from seelog`，说明seelog日志系统已经成功安装并且可以正常运行了。
+
+## 基于seelog的自定义日志处理
+seelog支持自定义日志处理，下面是我基于它自定义的日志处理包的部分内容：
+
+	package logs
+	
+	import (
+		"errors"
+		"fmt"
+		seelog "github.com/cihub/seelog"
+		"io"
+	)
+	
+	var Logger seelog.LoggerInterface
+	
+	func loadAppConfig() {
+		appConfig := `
+	<seelog minlevel="warn">
+	    <outputs formatid="common">
+	        <rollingfile type="size" filename="/data/logs/roll.log" maxsize="100000" maxrolls="5"/>
+			<filter levels="critical">
+	            <file path="/data/logs/critical.log" formatid="critical"/>
+	            <smtp formatid="criticalemail" senderaddress="astaxie@gmail.com" sendername="ShortUrl API" hostname="smtp.gmail.com" hostport="587" username="mailusername" password="mailpassword">
+	                <recipient address="xiemengjun@gmail.com"/>
+	            </smtp>
+	        </filter>
+	    </outputs>
+	    <formats>
+	        <format id="common" format="%Date/%Time [%LEV] %Msg%n" />
+		    <format id="critical" format="%File %FullPath %Func %Msg%n" />
+		    <format id="criticalemail" format="Critical error on our server!\n    %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
+	    </formats>
+	</seelog>
+	`
+		logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConfig))
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		UseLogger(logger)
+	}
+	
+	func init() {
+		DisableLog()
+		loadAppConfig()
+	}
+	
+	// DisableLog disables all library log output
+	func DisableLog() {
+		Logger = seelog.Disabled
+	}
+	
+	// UseLogger uses a specified seelog.LoggerInterface to output library log.
+	// Use this func if you are using Seelog logging system in your app.
+	func UseLogger(newLogger seelog.LoggerInterface) {
+		Logger = newLogger
+	}
+
+上面主要实现了三个函数，
+
+- `DisableLog`
+	
+	初始化全局变量Logger为seelog的禁用状态，主要为了防止Logger被多次初始化
+- `loadAppConfig`
+
+	根据配置文件初始化seelog的配置信息，这里我们把配置文件通过字符串读取设置好了，当然也可以通过读取XML文件。里面的配置说明如下：
+	
+	- seelog 
+	
+		minlevel参数可选，如果被配置,高于或等于此级别的日志会被记录，同理maxlevel。
+	- outputs
+		
+		输出信息的目的地，这里分成了两份数据，一份记录到log rotate文件里面。另一份设置了filter，如果这个错误级别是critical，那么将发送报警邮件。
+		
+	- formats
+	
+		定义了各种日志的格式
+	
+- `UseLogger`
+
+	设置当前的日志器为相应的日志处理
+	
+上面我们定义了一个自定义的日志处理包，下面就是使用示例：
+
+	package main
+	
+	import (
+		"net/http"
+		"project/logs"
+		"project/configs"
+		"project/routes"
+	)
+	
+	func main() {
+		addr, _ := configs.MainConfig.String("server", "addr")
+		logs.Logger.Info("Start server at:%v", addr)
+		err := http.ListenAndServe(addr, routes.NewMux())
+		logs.Logger.Critical("Server err:%v", err)
+	}
+
+## 发生错误发送邮件
+上面的例子解释了如何设置发送邮件，我们通过如下的smtp配置用来发送邮件：
+
+	<smtp formatid="criticalemail" senderaddress="astaxie@gmail.com" sendername="ShortUrl API" hostname="smtp.gmail.com" hostport="587" username="mailusername" password="mailpassword">
+		<recipient address="xiemengjun@gmail.com"/>
+	</smtp>
+
+邮件的格式通过criticalemail配置，然后通过其他的配置发送邮件服务器的配置，通过recipient配置接收邮件的用户，如果有多个用户可以再添加一行。
+
+要测试这个代码是否正常工作，可以在代码中增加类似下面的一个假消息。不过记住过后要把它删除，否则上线之后就会收到很多垃圾邮件。
+
+	logs.Logger.Critical("test Critical message")
+
+现在，只要我们的应用在线上记录一个Critical的信息，你的邮箱就会收到一个Email，这样一旦线上的系统出现问题，你就能立马通过邮件获知，就能及时的进行处理。			
+## 使用应用日志
+对于应用日志，每个人的应用场景可能会各不相同，有些人利用应用日志来做数据分析，有些人利用应用日志来做性能分析，有些人来做用户行为分析，还有些就是纯粹的记录，以方便应用出现问题的时候辅助查找问题。
+
+举一个例子，我们需要跟踪用户尝试登陆系统的操作。这里会把成功与不成功的尝试都记录下来。记录成功的使用"Info"日志级别，而不成功的使用"warn"级别。如果想查找所有不成功的登陆，我们可以利用linux的grep之类的命令工具，如下：
+
+	# cat /data/logs/roll.log | grep "failed login"
+	2012-12-11 11:12:00 WARN : failed login attempt from 11.22.33.44 username password
+
+通过这种方式我们就可以很方便的查找相应的信息，这样有利于我们针对应用日志做一些统计和分析。另外我们还需要考虑日志的大小，对于一个高流量的Web应用来说，日志的增长是相当可怕的，所以我们在seelog的配置文件里面设置了logrotate，这样就能保证日志文件不会因为不断变大而导致我们的磁盘空间不够引起问题。
+
+## 小结
+通过上面对seelog系统及如何基于它进行自定义日志系统的学习，现在我们可以很轻松的随需构建一个合适的功能强大的日志处理系统了。日志处理系统为数据分析提供了可靠的数据源，比如通过对日志的分析，我们可以进一步优化系统，或者应用出现问题时方便查找定位问题，另外seelog也提供了日志分级功能，通过对minlevel的配置,我们可以很方便的测试或发布版本的输出消息。
 
 ## links
    * [目录](<preface.md>)

12.2.md

@@ -1,5 +1,123 @@
 # 12.2 网站错误处理
+我们的Web应用一旦上线之后，那么各种错误出现的概率都有，Web应用日常运行中可能出现多种错误，具体如下所示：
 
+- 数据库错误：指与访问数据库服务器或数据相关的错误。例如，以下可能出现的一些数据库错误。
+	
+	- 连接错误：这一类错误可能是数据库服务器网络断开、用户名密码不正确、或者数据库不存在。
+	- 查询错误：使用的SQL非法导致错误，这样SQL错误如果程序经过严格的测试应该可以避免。
+	- 数据错误：数据库中的约束冲突，例如一个唯一字段中插入一条重复主键的值就会报错，但是如果你的应用程序在上线之前经过了严格的测试也是可以避免这类问题。
+- 应用运行时错误：这类错误范围很广，涵盖了代码中出现的几乎所有错误。可能的应用错误的情况如下：
+
+	- 文件系统和权限：应用读取不存在的文件，或者读取没有权限的文件、或者写入一个不允许写入的文件，这些都会导致一个错误。应用读取的文件如果格式不正确也会报错，例如配置文件应该是ini的配置格式，而设置成了json格式就会报错。
+	- 第三方应用：如果我们的应用程序耦合了其他第三方接口程序，例如应用程序发表文章之后自动调用接发微博的接口，所以这个接口必须正常运行才能完成我们发表一篇文章的功能。
+
+- HTTP错误：这些错误是根据用户的请求出现的错误，最常见的就是404请求，虽然可能会出现很多不同的错误，但其中比较常见的错误还有401未授权错误(需要认证才能访问的资源)、403禁止错误(不允许用户访问的资源)和503错误(程序内部出错)。
+- 操作系统出错：这类错误都是由于应用程序上的操作系统出现错误引起的，主要有操作系统的资源被分配完了，导致死机，还有操作系统的磁盘满了，导致无法写入，这样就会引起很多错误。
+- 网络出错：指两方便的错误，一方面是用户请求应用程序的时候出现网络断开，这样就导致连接中断，这种错误不会造成应用程序的崩溃，但是会影响用户访问的效果，另一方面是应用程序读取其他网络上的数据，这种网络断开会导致读取失败，这种需要对应用程序做有效的测试，能够避免这类问题出现的情况下程序崩溃。
+
+## 错误处理的目标
+在实现错误处理之前，我们必须明确错误处理想要达到的目标是什么，错误处理系统应该完成以下工作：
+
+- 通知访问用户出现错误了：不论出现的是一个系统错误还是用户错误，用户都应当知道Web应用出了问题，用户的这次请求无法正确的完成了。例如用户的错误请求我们显示一个统一的错误页面(404.html)，出现系统错误我们通过自定义的错误页面显示系统暂时不可用之类的错误页面(error.html)
+- 记录错误：系统出错错误时，一般就是我们调用函数的时候返回err不为nil的情况下，使用前面小节介绍的日志系统记录到日志文件，如果是一些致命错误通过邮件通知系统管理员，例如一般404之类的错误不需要发送邮件，只需要记录到日志系统。
+- 回滚当前的请求：如果一个用户请求过程中出现了一个服务器错误，那么已完成的操作需要回滚。下面来看一个例子：一个系统讲用户递交的表单保存到数据库，并将这个数据递交到一个第三方服务器，但是第三方服务器挂了，这就导致一个错误，那么先前存储到数据库的表单数据应该删除，而且应该通知用户系统出现错误了。
+- 保证现有程序可运行可服务：我们知道没有人能保证程序一定能够一直正常的运行着，万一哪一天程序崩溃了，那么我们就需要记录错误，然后立刻让程序重新运行起来，让程序继续提供服务，然后再通知系统管理员，通过日志等找出问题。
+
+## 如何处理错误
+错误处理其实我们已经在十一章第一小节里面有过介绍如何设计错误处理，这里我们再从一个例子详细的讲解一下，如何来处理不同的错误：
+
+- 通知用户出现错误：
+	
+	通知用户在访问页面的时候我们可以有两种错误：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操作
+		}
+
+## 如何处理异常
+我们知道在很多其他语言中有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里面实现的逻辑，针对一些特殊情况来设计。
+
+## 小结
+本小节总结了当我们的Web应用部署之后如何处理各种错误：网络错误、数据库错误、操作系统错误等，当错误发生时，我们的程序如何来正确的处理，显示友好的出错界面、回滚操作、记录日志、通知管理员等操作，最后介绍了如何来正确的处理错误和异常，一般的程序中错误和异常都是混淆的，但是在Go程序中错误和异常是有区分的，所以最后介绍了程序设计的时候如何来遵循这样的原则。
 ## links
    * [目录](<preface.md>)
    * 上一章: [应用日志](<12.1.md>)

12.3.md

@@ -1,4 +1,179 @@
 # 12.3 应用部署
+程序开发完毕之后，我们现在要部署Web应用程序了，但是我们如何来部署这些应用程序呢？因为Go程序编译之后是一个可执行文件，编写过C程序的读者一定知道使用daemon就可以完美的实现程序后台运行，但是目前Go还无法完美的实现daemon，因此，针对Go的应用程序部署，我们可以利用第三方工具来管理，第三方的工具有很多，例如Supervisord、upstart、daemontools等，这小节我介绍目前自己系统中采用的工具Supervisord。
+## deamon
+目前Go程序如果要实现daemon还不行，详细的见这个Go语言的bug：http://code.google.com/p/go/issues/detail?id=227，大概的意思说很难从现有的使用的线程中fork一个出来，因为没有一种简单的方法来确保所有已经使用的线程的状态一致性问题。
+
+但是我们可以看到很多网上的一些实现deamon的方法，例如下面两种方式：
+
+- 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。
+
+## Supervisord
+上面已经介绍了Go目前是有两种方案来实现他的daemon，但是官方本身还不支持这一块，所以还是建议大家采用第三方成熟工具来管理我们的应用程序，这里我给大家介绍一款目前使用比较广泛的进程管理软件：Supervisord。Supervisord是用Python实现的一款非常实用的进程管理工具。supervisord会帮你把管理的应用程序转成daemon程序，而且可以方便的通过命令开启、关闭、重启等操作，而且它管理的进程一旦奔溃会自动再次重新开启，这样就可以保证程序中断的情况下有自我修复功能。
+
+>我前面在应用中踩过一个坑，就是因为所有的应用程序都是由Supervisord父进程生出来的，那么当你修改了操作系统的文件描述符之后，别忘记重启Supervisord，光重启下面的应用程序没用。当初我就是系统安装好之后就先装了Supervisord，然后开始部署程序，修改文件描述符，重启程序，以为文件描述符已经是100000了，其实Supervisord这个时候还是默认的1024个，导致他管理的进程所有的描述符也是1024.开放之后压力一上来系统就开发报文件描述符用光了，查了很久才找到这个坑。
+
+### 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。
+
+### Supervisord配置
+Supervisord默认的配置文件路径为/etc/supervisord.conf，通过文本编辑器修改这个文件，下面是一个示例的配置文件：
+
+	;/etc/supervisord.conf
+	[unix_http_server]
+	file = /var/run/supervisor.sock
+	chmod = 0777
+	chown= root:root
+
+	[inet_http_server]
+	# Web管理界面设定
+	port=9001
+	username = admin
+	password = yourpassword
+
+	[supervisorctl]
+	; 必须和'unix_http_server'里面的设定匹配
+	serverurl = unix:///var/run/supervisord.sock
+
+	[supervisord]
+	logfile=/var/log/supervisord/supervisord.log ; (main log file;default $CWD/supervisord.log)
+	logfile_maxbytes=50MB       ; (max main logfile bytes b4 rotation;default 50MB)
+	logfile_backups=10          ; (num of main logfile rotation backups;default 10)
+	loglevel=info               ; (log level;default info; others: debug,warn,trace)
+	pidfile=/var/run/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
+	nodaemon=true              ; (start in foreground if true;default false)
+	minfds=1024                 ; (min. avail startup file descriptors;default 1024)
+	minprocs=200                ; (min. avail process descriptors;default 200)
+	user=root                 ; (default is current user, required if root)
+	childlogdir=/var/log/supervisord/            ; ('AUTO' child log dir, default $TEMP)
+
+	[rpcinterface:supervisor]
+	supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+	; 管理的单个进程的配置，可以添加多个program
+	[program:blogdemon]
+	command=/data/blog/blogdemon
+	autostart = true
+	startsecs = 5
+	user = root
+	redirect_stderr = true
+	stdout_logfile = /var/log/supervisord/blogdemon.log
+
+### Supervisord管理
+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，载入最新的配置文件，并按新的配置启动、管理所有进程。
+
+## 小结
+这小节我们介绍了如何实现Go的daemon，但是我们知道由于目前Go的daemon实现不是很完美，我们需要依靠第三方工具来实现应用程序的daemon管理，这里介绍了一个python写的进程管理工具Supervisord，通过Supervisord可以很方便的把我们的Go应用程序管理起来。
+
 
 ## links
    * [目录](<preface.md>)

12.4.md

@@ -1,4 +1,172 @@
 # 12.4 备份和恢复
+这小节我们要讨论应用程序管理的另一个方面：生成服务器上数据的备份和恢复。我们经常会遇到生成服务器的网络断了、硬盘坏了、操作系统奔溃、或者数据库不可用了等各种情况，所以我需要对我们的生成服务器上的应用、数据做异地灾备，冷备热备。在下面的介绍中，将讲解如何备份应用、如何备份Mysql数据库以及将其恢复，如何备份redis数据库以及恢复。
+
+## 应用备份
+在大多数集群坏境下，Web应用程序基本不需要备份，因为这个其实就是一个代码副本，我们在本地开发环境中，或者版本控制系统中已经保持了这些代码。但是很多时候，我们开发的站点需要用户动态来上传文件，那么我们需要对这些上传的文件进行备份，目前其实一种合适的做法是把和网站相关的需要存储的文件存储到云储存，这样即使系统奔溃我们的文件还在云储存，至少数据不会丢失。
+
+如果我们没有采用云储存的情况下，如何做到网站的备份呢？这里我们介绍一个文件同步工具rsync：rsync能够实现网站的备份，文件的同步，不同系统的文件的同步，如果是windows的话，需要windows版本cwrsync。
+
+### rsync安装
+rysnc的官方网站：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等编译开具才行；
+
+### rsync配置
+rsync主要有以下三个配置文件rsyncd.conf(主配置文件)、rsyncd.secrets(密码文件)、rsyncd.motd(rysnc服务器信息)。
+
+关于这几个文件的配置大家可以参考官方网站或者其他介绍rsync的网站，下面介绍服务器端和客户端如何开启
+
+- 服务端开启：
+
+		#/usr/bin/rsync --daemon  --config=/etc/rsyncd/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.0.100 为服务端的IP地址
+	6. ::www，注意是2个 : 号，www为服务端的配置文件 /etc/rsyncd.conf 中的[www]，意思是根据服务端上的/etc/rsyncd.conf来同步其中的[www]段内容，一个 : 号的时候，用于不根据配置文件，直接同步指定目录。
+	
+	为了让同步实时性，可以设置crontab，保持rsync每分钟同步，当然用户也可以根据文件的重要程度设置不同的同步频率。
+	
+
+## 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! Think 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    
+
+## MySQL恢复
+前面介绍MySQL备份分为热备份和冷备份，热备份主要是目的是为了能够实时的恢复，例如应用服务器出现了硬盘故障，那么我们可以通过修改配置文件把数据库的读取和写入改成slave，这样就可以尽量少时间的中断服务。
+
+但是有时候我们需要通过冷备份的SQL会进行数据恢复，既然有了数据库的备份，就可以通过命令导入：
+
+	mysql -u username -p databse < backup.sql
+	
+可以看到，导出和导入数据库数据都是相当简单，不过如果还需要管理权限，或者其他的一些字符集的设置的话，可能会稍微复杂一些，但是这些都是可以通过一些命令来完成的。
+
+## redis备份
+redis是目前我们使用最多的NOSQL，它的备份也分为两种：热备份和冷备份，redis也支持master/slave模式，所以我们的热备份可以通过这种方式实现，相应的配置大家可以参考官方的文档配置，相当的简单。我们这里介绍冷备份的方式：redis其实会定时的把内存里面的缓存数据保存到数据库文件里面，我们备份只要备份相应的文件就可以，然后利用前面介绍的rsync备份到异地机房就可以实现。
+
+## redis恢复
+redis的恢复分为热备份恢复和冷备份恢复，热备份恢复的目的和方法同MySQL的恢复一样，只要修改应用的相应的数据库连接即可。
+
+但是有时候我们需要根据冷备份来恢复数据，redis的冷备份恢复其实就是只要把保存的数据库文件copy到redis的编译目录，然后启动redis就可以了，redis在启动的时候会自动加载数据库文件到内存中，启动的速度根据数据库的文件大小来决定。
+
+## 小结
+本小节介绍了当我们应用部分完毕之后，如何做好灾备，包括文件的备份、数据库的备份，这里我们介绍了rsync如何同步文件，MySQL数据库和redis数据库如何备份和恢复，希望通过本小节的介绍，能够让作为开发的你对于线上产品的灾备方案提供一个参考。 
  
 ## links
    * [目录](<preface.md>)

12.5.md

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

12.md

@@ -1,5 +1,7 @@
 # 12 部署与维护
+到目前为止，我们前面已经介绍了如何开发程序、调试程序以及测试程序，正如人们常说的：开发最后的10%需要花费90%的时间，所以这一章我们将强调这最后的10%部分，要真正成为让人信任并使用的优秀应用，需要考虑到一些细节，以上所说的10%就是指这些小细节。
 
+本章我们将通过四个小节来介绍这些小细节的处理，第一小节介绍如何在生产服务上记录程序产生的日志，如何记录日志，第二小节介绍发生错误时我们的程序如何处理，如何保证尽量少的影响到用户的访问，第三小节介绍如何来部署Go的独立程序，由于目前Go程序还无法像C那样写成daemon，那么我们如何管理这样的进程程序后台运行呢？第四小节讲介绍应用数据的备份和恢复，尽量保证应用在奔溃的情况能够保持数据的完整性。
 ## 目录
   * 1 [应用日志](12.1.md)
   * 2 [网站错误处理](12.2.md)

13.1.md

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

13.2.md

@@ -0,0 +1,260 @@
+# 13.2 自定义路由器设计
+
+## HTTP路由
+HTTP路由组件负责将HTTP请求交到对应的函数处理(或者是一个struct的方法)，如前面小节所描述的结构图，路由在框架中相当于一个事件处理器，而这个事件包括：
+
+- 用户请求的路径(例如:/user/123,/article/123)，当然还有查询串信息(例如?id=11)
+- HTTP的请求method(GET、POST、PUT、DELETE、PATCH等)
+
+路由器就是根据用户请求的这个信息定位到相应的处理函数。
+## 默认的路由实现
+在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.Handle("/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来添加路由，两个参数，第一个参数是前面所讲的用户请求的路径(Go中保存在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
+		}
+	}
+
+
+## beego框架路由实现
+目前几乎所有的Web应用路由实现都是基于http默认的路由器，但是默认的路由器有几个限制点：
+
+- 不支持参数设定，例如/user/:uid 这种泛类型匹配
+- 无法很好的支持REST模式，无法限制访问的方法，例如上面的例子中，用户访问/foo，可以用GET、POST、DELETE、HEAD等方式访问
+- 默认的路由规则太多了，我前面自己开发了一个API的应用，路由规则有三十几条，这种路由多了之后其实可以进一步简化，通过struct的方法进行一种简化
+
+beego框架的路由器基于上面的几点限制考虑设计了一种REST方式的路由实现，路由设计也是基于上面的默认设计的两点来考虑：存储路由和转发路由
+
+### 存储路由
+针对前面所说的限制点，我们首先要解决参数支持就需要用到正则，第二和第三点我们通过一种变通的方法来解决，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)
+	
+	}
+	
+### 静态路由实现
+上面我们实现的动态路由的实现，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")
+	
+
+### 转发路由
+转发路由是基于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)
+		}
+	}
+
+### 使用入门
+基于这样的路由设计之后就可以解决前面所说的三个限制点，使用的方式如下所示：
+
+基本的使用注册路由：
+
+	beego.BeeApp.RegisterController("/", &controllers.MainController{})
+	
+参数注册：
+
+	beego.BeeApp.RegisterController("/:param", &controllers.UserController{})
+	
+正则匹配：
+
+	beego.BeeApp.RegisterController("/users/:uid([0-9]+)", &controllers.UserController{})
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [数据库设计](<13.2.md>)
+   * 下一节: [controller设计](<13.4.md>)

13.3.md

@@ -0,0 +1,162 @@
+# 13.3 controller设计
+
+传统的MVC框架大多数是基于Action设计的后缀式映射，然而目前流行的Web趋势是REST风格的架构。尽管使用Filter或者rewrite能够通过URL重写实现REST风格的URL，但是为什么不直接设计一个全新的REST风格的 MVC框架呢？本小节就是基于这种思路来讲述如何从头设计一个基于REST风格的MVC框架中的controller，最大限度地简化Web应用的开发，您甚至编写一行代码就可以实现“Hello, world”。
+
+## controller作用
+MVC设计模式是目前Web应用开发中最常见的一种架构模式，通过分离 Model（模型）、View（视图）和 Controller（控制器），可以更容易实现易于扩展的UI。Model指后台返回的数据；View指需要渲染的页面，通常是模板页面，渲染后的结果通常是HTML；Controller指Web开发人员编写的处理不同URL的控制器，如前面小节讲述的路由就是转发到控制器的过程，controller在整个的MVC框架中起到了一个核心的作用，处理业务逻辑，因此控制器是整个框架中必不可少的一部分，Model和View会根据不同的业务可以不写，例如没有数据处理的逻辑处理，没有页面输出的302调整之类的就不需要Model和View，但是controller是必不可少的。
+
+## 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()    执行完之后执行的操作，每个继承的子类可以来实现该函数
+
+## 应用指南
+上面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函数，就会显示如下界面：
+
+![](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>
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [自定义路由器设计](<13.2.md>)
+   * 下一节: [日志和配置设计](<13.4.md>)

13.4.md

@@ -0,0 +1,248 @@
+# 13.4 日志和配置设计
+
+## 日志和配置的重要性
+前面已经介绍过日志在我们程序开发中起着很重要的作用，通过日志我们可以记录调试我们的信息，当初介绍过一个日志系统seelog，根据不同的level输出不同的日志，这个对于程序开发和程序部署来说至关重要。我们可以在程序开发中设置level低一点，部署的时候把level设置高，这样我们开发中的调试信息可以屏蔽掉。
+
+配置模块对于应用部署牵涉到服务器不同的一些配置信息非常有用，例如一些数据库配置信息、监听端口、监听地址等都是可以通过配置文件来配置，这样我们的应用程序就具有很强的灵活性，可以通过配置文件的配置部署在不同的机器上，可以连接不同的数据库之类的。
+
+## 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 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这三个函数都不会有任何的输出，以此类推。
+
+## 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]
+	}
+
+## 应用指南
+下面这个函数是我一个应用中的例子，用来获取远程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"
+	
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [controller设计](<13.3.md>)
+   * 下一节: [实现博客的增删改](<13.5.md>)

13.5.md

@@ -0,0 +1,259 @@
+# 13.5 实现博客的增删改
+
+前面介绍了beego框架实现的整体构思以及部分实现的伪代码，这小节介绍通过beego建立一个博客系统，包括博客浏览、添加、修改、删除等操作。
+## 博客目录
+博客目录如下所示：
+
+	/main.go
+	/views:
+	    /view.tpl
+	    /new.tpl
+	    /layout.tpl
+	    /index.tpl
+	    /edit.tpl
+	/models/model.go
+	/controllers:
+	    /index.go
+		/view.go
+		/new.go
+		/delete.go
+		/edit.go			
+
+
+## 博客路由
+博客主要的路由规则如下所示：
+
+	//显示博客首页
+	beego.RegisterController("/", &controllers.IndexController{})
+	//查看博客详细信息
+	beego.RegisterController("/view/:id([0-9]+)", &controllers.ViewController{})
+	//新建博客博文
+	beego.RegisterController("/new", &controllers.NewController{})
+	//删除博文
+	beego.RegisterController("/delete/:id([0-9]+)", &controllers.DeleteController{})
+	//编辑博文
+	beego.RegisterController("/edit/:id([0-9]+)", &controllers.EditController{})
+
+
+## 数据库结构
+数据库设计最简单的博客信息
+
+	CREATE TABLE entries (
+	    id INT AUTO_INCREMENT,
+	    title TEXT,
+	    content TEXT,
+	    created DATETIME,
+	    primary key (id)
+	);
+
+## 控制器
+IndexController:
+
+	type IndexController struct {
+		beego.Controller
+	}
+	
+	func (this *IndexController) Get() {
+		this.Data["blogs"] = models.GetAll()
+		this.Layout = "layout.tpl"
+		this.TplNames = "index.tpl"
+	}
+	
+ViewController:
+
+	type ViewController struct {
+		beego.Controller
+	}
+	
+	func (this *ViewController) Get() {
+		inputs := this.Input()
+		id, _ := strconv.Atoi(this.Ctx.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() {
+		inputs := this.Input()
+		id, _ := strconv.Atoi(this.Ctx.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() {
+		inputs := this.Input()
+		id, _ := strconv.Atoi(this.Ctx.Params[":id"])
+		this.Data["Post"] = models.DelBlog(id)
+		this.Ctx.Redirect(302, "/")
+	}	
+
+## 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(&blogs)
+		return
+	}
+	
+	func SaveBlog(blog Blog) (bg Blog) {
+		db := GetLink()
+		db.Save(&blog)
+		return bg
+	}
+	
+	func DelBlog(blog Blog) {
+		db := GetLink()
+		db.Delete(&blog)
+		return
+	}
+
+
+## view层
+
+layout.tpl
+
+	<html>
+	<head>
+	    <title>My Blog</title>
+	    <style>
+	        #menu {
+	            width: 200px;
+	            float: right;
+	        }
+	    </style>
+	</head>
+	<body>
+	
+	<ul id="menu">
+	    <li><a href="/">Home</a></li>
+	    <li><a href="/new">New Post</a></li>
+	</ul>
+	
+	{{.LayoutContent}}
+	
+	</body>
+	</html>
+	
+index.tpl
+
+	<h1>Blog posts</h1>
+
+	<ul>
+	{{range .blogs}}
+	    <li>
+	        <a href="/view/{{.Id}}">{{.Title}}</a> 
+	        from {{.Created}}
+	        <a href="/edit/{{.Id}}">Edit</a>
+	        <a href="/delete/{{.Id}}">Delete</a>
+	    </li>
+	{{end}}
+	</ul>
+
+view.tpl
+
+	<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>
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [数据库操作](<13.4.md>)
+   * 下一节: [小结](<13.6.md>)

13.6.md

@@ -0,0 +1,7 @@
+# 13.6 小结
+这一章我们主要介绍了如何实现一个基础的Go语言框架，框架包含有路由设计，由于Go内置的http包中路由的一些不足点，我们设计了动态路由规则，然后介绍了MVC模式中的Controller设计，controller实现了REST的实现，这个主要思路来源于tornado框架，然后设计实现了模板的layout以及自动化渲染等技术，主要采用了Go内置的模板引擎，最后我们介绍了一些辅助的日志、配置等信息的设计，通过这些设计我们实现了一个基础的框架beego，目前该框架已经开源在github，最后我们通过beego实现了一个博客系统，通过实例代码详细的展现了如何快速的开发一个站点。
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [实现博客的增删改](<13.5.md>)
+   * 下一节: [扩展博客管理系统](<14.md>)

13.md

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

14.md

@@ -0,0 +1,14 @@
+# 14 扩展Web框架
+
+## 目录
+ * 1 [静态文件支持](14.1.md)
+ * 2 [Session支持](14.2.md)
+ * 3 [表单支持](14.3.md)
+ * 4 [用户认证](14.4.md)
+ * 5 [多语言支持](14.5.md)
+ * 6 [小结](14.6.md)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第十三章总结](<13.6.md>)
+   * 下一节: [静态文件支持](<14.1.md>)

2.1.md

@@ -13,12 +13,12 @@
 	import "fmt"
 
 	func main() {
-		fmt.Printf("Hello, world or καλημ ́ρα κóσμ or こんにちは世界\n")
+		fmt.Printf("Hello, world or 你好，世界 or καλημ ́ρα κóσμ or こんにちは世界\n")
 	}
 
 输出如下：
 
-	Hello, world or καλημ ́ρα κóσμ or こんにちは世界
+	Hello, world or 你好，世界 or καλημ ́ρα κóσμ or こんにちは世界
 
 ## 详解
 首先我们要了解一个概念，Go程序是通过`package`来组织的

2.2.md

@@ -104,7 +104,9 @@ Go对于已声明但未使用的变量会在编译阶段报错，比如下面的
 >如下的代码会产生错误
 >
 >>	var a int8
+
 >>	var b int32
+
 >>	c:=a + b
 >
 >另外，尽管int的长度是32 bit, 但int 与 int32并不可以互用。
@@ -326,8 +328,8 @@ slice有一些简便的操作
 
 	// 演示一些简便操作
 	aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
-	aSlice = array[5:] // 等价于aSlice = array[5:9] aSlice包含元素: f,g,h,i,j
+	aSlice = array[5:] // 等价于aSlice = array[5:10] aSlice包含元素: f,g,h,i,j
-	aSlice = array[:]  // 等价于aSlice = array[0:9] 这样aSlice包含了全部的元素
+	aSlice = array[:]  // 等价于aSlice = array[0:10] 这样aSlice包含了全部的元素
 
 	// 从slice中获取slice
 	aSlice = array[3:7]  // aSlice包含元素: d,e,f,g，len=4，cap=7

2.6.md

@@ -234,91 +234,91 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 
 	让我们通过一个例子来更加深入的理解。
 
-	package main
+		package main
 
-	import (
+		import (
-		"fmt"
+			"fmt"
-		"strconv"
+			"strconv"
-	)
+		)
 
-	type Element interface{}
+		type Element interface{}
-	type List [] Element
+		type List [] Element
 
-	type Person struct {
+		type Person struct {
-		name string
+			name string
-		age int
+			age int
-	}
+		}
 
-	//定义了String方法，实现了fmt.Stringer
+		//定义了String方法，实现了fmt.Stringer
-	func (p Person) String() string {
+		func (p Person) String() string {
-		return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
+			return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
-	}
+		}
 
-	func main() {
+		func main() {
-		list := make(List, 3)
+			list := make(List, 3)
-		list[0] = 1 // an int
+			list[0] = 1 // an int
-		list[1] = "Hello" // a string
+			list[1] = "Hello" // a string
-		list[2] = Person{"Dennis", 70}
+			list[2] = Person{"Dennis", 70}
 
-		for index, element := range list {
+			for index, element := range list {
-			if value, ok := element.(int); ok {
+				if value, ok := element.(int); ok {
-				fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
+					fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
-			} else if value, ok := element.(string); ok {
+				} else if value, ok := element.(string); ok {
-				fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
+					fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
-			} else if value, ok := element.(Person); ok {
+				} else if value, ok := element.(Person); ok {
-				fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
+					fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
-			} else {
+				} else {
-				fmt.Println("list[%d] is of a different type", index)
+					fmt.Println("list[%d] is of a different type", index)
+				}
 			}
 		}
-	}
 
-是不是很简单啊，同时你是否注意到了多个ifs里面，还记得我前面介绍流程里面讲过，if里面允许初始化变量。
+	是不是很简单啊，同时你是否注意到了多个ifs里面，还记得我前面介绍流程里面讲过，if里面允许初始化变量。
 
-也许你注意到了，我们断言的类型越多，那么ifelse也就越多，所以才引出了下面要介绍的switch。
+	也许你注意到了，我们断言的类型越多，那么ifelse也就越多，所以才引出了下面要介绍的switch。
 - switch测试
 
-最好的讲解就是代码例子，现在让我们重写上面的这个实现
+	最好的讲解就是代码例子，现在让我们重写上面的这个实现
 
-	package main
+		package main
 
-	import (
+		import (
-		"fmt"
+			"fmt"
-		"strconv"
+			"strconv"
-	)
+		)
 
-	type Element interface{}
+		type Element interface{}
-	type List [] Element
+		type List [] Element
 
-	type Person struct {
+		type Person struct {
-		name string
+			name string
-		age int
+			age int
-	}
+		}
 
-	//打印
+		//打印
-	func (p Person) String() string {
+		func (p Person) String() string {
-		return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
+			return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
-	}
+		}
 
-	func main() {
+		func main() {
-		list := make(List, 3)
+			list := make(List, 3)
-		list[0] = 1 //an int
+			list[0] = 1 //an int
-		list[1] = "Hello" //a string
+			list[1] = "Hello" //a string
-		list[2] = Person{"Dennis", 70}
+			list[2] = Person{"Dennis", 70}
 
-		for index, element := range list{
+			for index, element := range list{
-			switch value := element.(type) {
+				switch value := element.(type) {
-				case int:
+					case int:
-					fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
+						fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
-				case string:
+					case string:
-					fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
+						fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
-				case Person:
+					case Person:
-					fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
+						fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
-				default:
+					default:
-					fmt.Println("list[%d] is of a different type", index)
+						fmt.Println("list[%d] is of a different type", index)
+				}
 			}
 		}
-	}
 
 	这里有一点需要强调的是：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。
 

2.7.md

@@ -80,7 +80,7 @@ channel通过操作符`<-`来接收和发送数据
 		fmt.Println(x, y, x + y)
 	}
 
-默认情况下，channel接收和发送数据都是阻塞的除非另一端已经准备好，这样就使得Goroutines同步变的更加的简单，而不需要显式的lock。所谓阻塞，也就是如果读取（value := <-ch）它将会被阻塞，直到有数据接收。其次，任何发送（ch<-5）将会被阻塞，直到数据被读出。无缓冲channel 是在多个goroutine之间同步很棒的工具。
+默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得Goroutines同步变的更加的简单，而不需要显式的lock。所谓阻塞，也就是如果读取（value := <-ch）它将会被阻塞，直到有数据接收。其次，任何发送（ch<-5）将会被阻塞，直到数据被读出。无缓冲channel 是在多个goroutine之间同步很棒的工具。
 
 ## Buffered Channels
 上面我们介绍了默认的非缓存类型的channel，不过Go也允许指定channel的缓冲大小，很简单，就是channel可以存储多少元素。ch:= make(chan bool, 4)，创建了可以存储4个元素的bool 型channel。在这个channel 中，前4个元素可以无阻塞的写入。当写入第5个元素时，代码将会阻塞，直到其他goroutine从channel 中读取一些元素，腾出空间。

3.3.md

@@ -33,7 +33,7 @@ Handler：处理请求和生成返回信息的处理逻辑
 
 前面小节的代码里面我们可以看到，Go是通过一个函数来操作这个事情的`ListenAndServe`来监听起来的，这个底层其实这样处理的：初始化一个server对象，然后调用了`net.Listen("tcp", addr)`，也就是底层用TCP协议搭建了一个服务，然后监控我们设置的端口。
 
-监控之后如何接收客户端的请求呢？上面代码执行监控端口之后，调用了`srv.Sere(net.Listener)`函数，这个函数就是处理接收客户端的请求信息。这个函数里面起了一个`for{}`，首先通过Listener接收请求，其次创建一个Conn，最后单独开了一个goroutine，把这个请求的数据当做参数扔给这个conn去服务：`go c.serve()`。这个就是高并发体现了，用户的每一次请求都是在一个新的goroutine去服务，相互不影响。
+监控之后如何接收客户端的请求呢？上面代码执行监控端口之后，调用了`srv.Serve(net.Listener)`函数，这个函数就是处理接收客户端的请求信息。这个函数里面起了一个`for{}`，首先通过Listener接收请求，其次创建一个Conn，最后单独开了一个goroutine，把这个请求的数据当做参数扔给这个conn去服务：`go c.serve()`。这个就是高并发体现了，用户的每一次请求都是在一个新的goroutine去服务，相互不影响。
 
 那么如何具体分配到相应的函数来处理请求呢？conn首先会解析request:`c.readRequest()`,然后获取相应的handler:`handler := c.server.Handler`，也就是我们刚才在调用函数`ListenAndServe`时候的第二个参数，我们前面例子传递的是nil，也就是为空，那么默认获取`handler = DefaultServeMux`,那么这个变量用来做什么的呢？对，这个变量就是一个路由器，它用来匹配url跳转到其相应的handle函数，那么这个我们有设置过吗?有，我们调用的代码里面第一句不是调用了`http.HandleFunc("/", sayhelloName)`嘛。这个作用就是注册了请求`/`的路由规则，当请求uri为"/"，路由就会转到函数sayhelloName，DefaultServeMux会调用ServeHTTP方法，这个方法内部其实就是调用sayhelloName本身，最后通过写入response的信息反馈到客户端。
 

3.4.md

@@ -22,7 +22,7 @@ Go在等待客户端请求里面是这样写的：
 它的结构如下：
 
 	type ServeMux struct {
-		mu sync.RWMutex   //锁，由于请求设计到并发处理，因此这里需要一个锁机制
+		mu sync.RWMutex   //锁，由于请求涉及到并发处理，因此这里需要一个锁机制
 		m  map[string]muxEntry  // 路由规则，一个string对应一个mux实体，这里的string就是注册的路由表达式
 	}
 

4.1.md

@@ -1,6 +1,6 @@
 # 4.1处理表单的输入
 
-我们先来看一个表单递交的例子，我们有如下的表单内容，命名成文件login.gtpl(放入当前新建项目的目录里面)
+先来看一个表单递交的例子，我们有如下的表单内容，命名成文件login.gtpl(放入当前新建项目的目录里面)
 
 	<html>
 	<head>
@@ -32,7 +32,7 @@ http包里面有一个很简单的方式就可以获取，我们在前面web的
 
 	func sayhelloName(w http.ResponseWriter, r *http.Request) {
 		r.ParseForm()       //解析url传递的参数，对于POST则解析响应包的主体（request body）
-		//注意:如果没有调用parseForm方法，下面无法获取表单的数据
+		//注意:如果没有调用ParseForm方法，下面无法获取表单的数据
 		fmt.Println(r.Form) //这些信息是输出到服务器端的打印信息
 		fmt.Println("path", r.URL.Path)
 		fmt.Println("scheme", r.URL.Scheme)

4.2.md

@@ -1,6 +1,6 @@
 # 4.2验证表单的输入
 
-我们开发Web的一个原则就是，不能信任用户输入的任何信息，所以验证和过滤用户的输入信息就变得非常重要，我们经常会在微博、新闻中听到某某网站被入侵了，存在什么漏洞，这些大多是是因为网站对于用户输入的信息没有做严格的验证引起的，所以为了编写出安全可靠的Web程序，验证表单输入的意义重大。
+开发Web的一个原则就是，不能信任用户输入的任何信息，所以验证和过滤用户的输入信息就变得非常重要，我们经常会在微博、新闻中听到某某网站被入侵了，存在什么漏洞，这些大多是是因为网站对于用户输入的信息没有做严格的验证引起的，所以为了编写出安全可靠的Web程序，验证表单输入的意义重大。
 
 我们平常编写Web应用主要有两方面的数据验证，一个是在页面端的js验证(目前在这方面有很多的插件库，比如ValidationJS插件)，一个是在服务器端的验证，我们这小节讲解的是如何在服务器端验证。
 

5.2.md

@@ -34,7 +34,7 @@ Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持data
 
 如下示例将示范如何使用database/sql接口对数据库表进行增删改查操作
 
-package main
+	package main
 
 	import (
 		_ "code.google.com/p/go-mysql-driver/mysql"
@@ -99,6 +99,8 @@ package main
 
 		fmt.Println(affect)
 
+		db.Close()
+
 	}
 
 	func checkErr(err error) {

5.3.md

@@ -94,6 +94,8 @@ Go支持sqlite的驱动也比较多，但是好多都是不支持database/sql接
 
 		fmt.Println(affect)
 
+		db.Close()
+
 	}
 
 	func checkErr(err error) {

5.4.md

@@ -104,6 +104,8 @@ package main
 
 		fmt.Println(affect)
 
+		db.Close()
+
 	}
 
 	func checkErr(err error) {

6.1.md

@@ -11,7 +11,7 @@ cookie，简而言之就是在本地计算机保存一些用户操作的历史
 
 ![](images/6.1.cookie2.png?raw=true)
 
-session，简而言之就是在服务器上保存用户操作的历史信息。但该方式下，仍然需要将发送请求的客户端与session对象进行对应，所以可以借助cookie机制来获取客户端的标识（即session id），也可以通过GET方式将id提交给服务器。session id，即服务器上session对象文件的名称，由服务器负责产生，保证随机性与唯一性，相当于一个随机密钥，避免在握手或传输中暴露用户真实密码。
+session，简而言之就是在服务器上保存用户操作的历史信息。服务器使用session id来标识session，session id由服务器负责产生，保证随机性与唯一性，相当于一个随机密钥，避免在握手或传输中暴露用户真实密码。但该方式下，仍然需要将发送请求的客户端与session进行对应，所以可以借助cookie机制来获取客户端的标识（即session id），也可以通过GET方式将id提交给服务器。
 
 ![](images/6.1.session.png?raw=true)
 

7.1.md

@@ -52,11 +52,11 @@ data接收的是XML数据流，v是需要输出的结构，定义为interface，
 
 	func main() {
 		file, err := os.Open("servers.xml") // For read access.		
-		defer file.Close()
 		if err != nil {
 			fmt.Printf("error: %v", err)
 			return
 		}
+		defer file.Close()
 		data, err := ioutil.ReadAll(file)
 		if err != nil {
 			fmt.Printf("error: %v", err)

8.1.md

@@ -160,7 +160,7 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
 
 	func main() {
 		service := ":7777"
-		tcpAddr, err := net.ResolveTCPAddr("ip4", service)
+		tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
 		checkError(err)
 		listener, err := net.ListenTCP("tcp", tcpAddr)
 		checkError(err)
@@ -196,7 +196,7 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
 
 	func main() {
 		service := ":1200"
-		tcpAddr, err := net.ResolveTCPAddr("ip4", service)
+		tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
 		checkError(err)
 		listener, err := net.ListenTCP("tcp", tcpAddr)
 		checkError(err)
@@ -211,7 +211,7 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
 
 	func handleClient(conn net.Conn) {
 		defer conn.Close()
-		daytime := time.LocalTime().String()
+		daytime := time.Now().String()
 		conn.Write([]byte(daytime)) // don't care about return value
 		// we're finished with this client
 	}
@@ -306,7 +306,7 @@ Go语言包中处理UDP Socket和TCP Socket不同的地方就是在服务器端
 		if err != nil {
 			return
 		}
-		daytime := time.LocalTime().String()
+		daytime := time.Now().String()
 		conn.WriteToUDP([]byte(daytime), addr)
 	}
 	func checkError(err error) {

9.1.md

@@ -15,7 +15,7 @@ CSRF（Cross-site request forgery），中文名称：跨站请求伪造，也
 从上图可以看出，要完成一次CSRF攻击，受害者必须依次完成两个步骤 ：
 
 - 1.登录受信任网站A，并在本地生成Cookie 。
-- 2.在不登出A的情况下，访问危险网站B。
+- 2.在不退出A的情况下，访问危险网站B。
 
 看到这里，读者也许会问：“如果我不满足以上两个条件中的任意一个，就不会受到CSRF的攻击”。是的，确实如此，但你不能保证以下情况不会发生：
 

README.md

@@ -30,9 +30,6 @@
 
 这样读者就可以把相应的Markdown文件编译成html文件，执行`go build build.go`，执行生成的文件，就会在底目录下生成相应的html文件
 
-## 如何编译
-目前可以把相应的Markdown编译成html文件，执行`go build build.go`，执行生成的文件，就会在底目录下生成相应的html文件。
-
 ## 交流
 欢迎大家加入QQ群：259316004 《Go Web编程》专用交流群
 

preface.md

@@ -76,16 +76,17 @@
  - 12.3 [应用部署](12.3.md)
  - 12.4 [备份和恢复](12.4.md)
  - 12.5 [小结](12.5.md)
-* 13.构建博客系统　
+* 13.[如何设计一个Web框架](13.md)　
- - 13.1 创建数据库表　
+ - 13.1 [项目规划](13.1.md)　
- - 13.2 建立对象类
+ - 13.2 [自定义路由器设计](13.2.md)
- - 13.3 创建控制器管理博客帖子
+ - 13.3 [controller设计](13.3.md)
- - 13.4 创建和编辑博客帖子　
+ - 13.4 [日志和配置设计](13.4.md)
- - 13.5 预览博客帖子
+ - 13.5 [实现博客的增删改](13.5.md)
- - 13.6 更新博客帖子的状态
+ - 13.6 [小结](13.6.md)　
- - 13.7 小结　
+* 14.[扩展Web框架](14.md)
-* 14.扩展博客管理系统　
+ - 14.1 [静态文件支持](14.1.md)
- - 14.1 在博客管理系统索引页面上列出帖子
+ - 14.2 [Session支持](14.2.md)
- - 14.2 为博客各月概要增加Ajax功能
+ - 14.3 [表单支持](14.3.md)
- - 14.3 集成WYSIWYG编辑器
+ - 14.4 [用户认证](14.4.md)
- - 14.4 小结　
+ - 14.5 [多语言支持](14.5.md)
+ - 14.6 [小结](14.6.md)