修改目录结果

02.0.md → ebook/02.0.md

-# 2 Go语言基础
-
-Go是一门类似C的编译型语言，但是它的编译速度非常快。这门语言的关键字总共也就二十五个，比英文字母还少一个，这对于我们的学习来说就简单了很多。先让我们看一眼这些关键字都长什么样：
-
-	break    default      func    interface    select
-	case     defer        go      map          struct
-	chan     else         goto    package      switch
-	const    fallthrough  if      range        type
-	continue for          import  return       var
-
-在接下来的这一章中，我将带领你去学习这门语言的基础。通过每一小节的介绍，你将发现，Go的世界是那么地简洁，设计是如此地美妙，编写Go将会是一件愉快的事情。等回过头来，你就会发现这二十五个关键字是多么地亲切。
-
-## 目录
-![](images/navi2.png?raw=true)
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第一章总结](<01.5.md>)
-   * 下一节: [你好，Go](<02.1.md>)
+# 2 Go语言基础
+
+Go是一门类似C的编译型语言，但是它的编译速度非常快。这门语言的关键字总共也就二十五个，比英文字母还少一个，这对于我们的学习来说就简单了很多。先让我们看一眼这些关键字都长什么样：
+
+	break    default      func    interface    select
+	case     defer        go      map          struct
+	chan     else         goto    package      switch
+	const    fallthrough  if      range        type
+	continue for          import  return       var
+
+在接下来的这一章中，我将带领你去学习这门语言的基础。通过每一小节的介绍，你将发现，Go的世界是那么地简洁，设计是如此地美妙，编写Go将会是一件愉快的事情。等回过头来，你就会发现这二十五个关键字是多么地亲切。
+
+## 目录
+![](images/navi2.png?raw=true)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第一章总结](<01.5.md>)
+   * 下一节: [你好，Go](<02.1.md>)

02.4.md → ebook/02.4.md

-# 2.4 struct类型
-## struct
-Go语言中，也和C或者其他语言一样，我们可以声明新的类型，作为其它类型的属性或字段的容器。例如，我们可以创建一个自定义类型`person`代表一个人的实体。这个实体拥有属性：姓名和年龄。这样的类型我们称之`struct`。如下代码所示:
-
-	type person struct {
-		name string
-		age int
-	}
-看到了吗？声明一个struct如此简单，上面的类型包含有两个字段
-- 一个string类型的字段name，用来保存用户名称这个属性
-- 一个int类型的字段age,用来保存用户年龄这个属性
-
-如何使用struct呢？请看下面的代码
-
-	type person struct {
-		name string
-		age int
-	}
-
-	var P person  // P现在就是person类型的变量了
-
-	P.name = "Astaxie"  // 赋值"Astaxie"给P的name属性.
-	P.age = 25  // 赋值"25"给变量P的age属性
-	fmt.Printf("The person's name is %s", P.name)  // 访问P的name属性.
-除了上面这种P的声明使用之外，还有两种声明使用方式
-
-- 1.按照顺序提供初始化值
-
-		P := person{"Tom", 25}
-
-- 2.通过`field:value`的方式初始化，这样可以任意顺序
-
-	P := person{age:24, name:"Tom"}
-
-下面我们看一个完整的使用struct的例子
-
-	package main
-	import "fmt"
-
-	// 声明一个新的类型
-	type person struct {
-		name string
-		age int
-	}
-
-	// 比较两个人的年龄，返回年龄大的那个人，并且返回年龄差
-	// struct也是传值的
-	func Older(p1, p2 person) (person, int) {
-		if p1.age>p2.age {  // 比较p1和p2这两个人的年龄
-			return p1, p1.age-p2.age
-		}
-		return p2, p2.age-p1.age
-	}
-
-	func main() {
-		var tom person
-
-		// 赋值初始化
-		tom.name, tom.age = "Tom", 18
-
-		// 两个字段都写清楚的初始化
-		bob := person{age:25, name:"Bob"}
-
-		// 按照struct定义顺序初始化值
-		paul := person{"Paul", 43}
-
-		tb_Older, tb_diff := Older(tom, bob)
-		tp_Older, tp_diff := Older(tom, paul)
-		bp_Older, bp_diff := Older(bob, paul)
-
-		fmt.Printf("Of %s and %s, %s is older by %d years\n",
-			tom.name, bob.name, tb_Older.name, tb_diff)
-
-		fmt.Printf("Of %s and %s, %s is older by %d years\n",
-			tom.name, paul.name, tp_Older.name, tp_diff)
-
-		fmt.Printf("Of %s and %s, %s is older by %d years\n",
-			bob.name, paul.name, bp_Older.name, bp_diff)
-	}
-
-### struct的匿名字段
-我们上面介绍了如何定义一个struct，定义的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。
-
-当匿名字段是一个struct的时候，那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。
-
-让我们来看一个例子，让上面说的这些更具体化
-
-	package main
-	import "fmt"
-
-	type Human struct {
-		name string
-		age int
-		weight int
-	}
-
-	type Student struct {
-		Human  // 匿名字段，那么默认Student就包含了Human的所有字段
-		speciality string
-	}
-
-	func main() {
-		// 我们初始化一个学生
-		mark := Student{Human{"Mark", 25, 120}, "Computer Science"}
-
-		// 我们访问相应的字段
-		fmt.Println("His name is ", mark.name)
-		fmt.Println("His age is ", mark.age)
-		fmt.Println("His weight is ", mark.weight)
-		fmt.Println("His speciality is ", mark.speciality)
-		// 修改对应的备注信息
-		mark.speciality = "AI"
-		fmt.Println("Mark changed his speciality")
-		fmt.Println("His speciality is ", mark.speciality)
-		// 修改他的年龄信息
-		fmt.Println("Mark become old")
-		mark.age = 46
-		fmt.Println("His age is", mark.age)
-		// 修改他的体重信息
-		fmt.Println("Mark is not an athlet anymore")
-		mark.weight += 60
-		fmt.Println("His weight is", mark.weight)
-	}
-
-图例如下:
-
-![](images/2.4.student_struct.png?raw=true)
-
-图2.7 Student和Human的方法继承
-
-我们看到Student访问属性age和name的时候，就像访问自己所有用的字段一样，对，匿名字段就是这样，能够实现字段的继承。是不是很酷啊？还有比这个更酷的呢，那就是student还能访问Human这个字段作为字段名。请看下面的代码，是不是更酷了。
-
-	mark.Human = Human{"Marcus", 55, 220}
-	mark.Human.age -= 1
-
-通过匿名访问和修改字段相当的有用，但是不仅仅是struct字段哦，所有的内置类型和自定义类型都是可以作为匿名字段的。请看下面的例子
-
-	package main
-	import "fmt"
-
-	type Skills []string
-
-	type Human struct {
-		name string
-		age int
-		weight int
-	}
-
-	type Student struct {
-		Human  // 匿名字段，struct
-		Skills // 匿名字段，自定义的类型string slice
-		int    // 内置类型作为匿名字段
-		speciality string
-	}
-
-	func main() {
-		// 初始化学生Jane
-		jane := Student{Human:Human{"Jane", 35, 100}, speciality:"Biology"}
-		// 现在我们来访问相应的字段
-		fmt.Println("Her name is ", jane.name)
-		fmt.Println("Her age is ", jane.age)
-		fmt.Println("Her weight is ", jane.weight)
-		fmt.Println("Her speciality is ", jane.speciality)
-		// 我们来修改他的skill技能字段
-		jane.Skills = []string{"anatomy"}
-		fmt.Println("Her skills are ", jane.Skills)
-		fmt.Println("She acquired two new ones ")
-		jane.Skills = append(jane.Skills, "physics", "golang")
-		fmt.Println("Her skills now are ", jane.Skills)
-		// 修改匿名内置类型字段
-		jane.int = 3
-		fmt.Println("Her preferred number is", jane.int)
-	}
-
-从上面例子我们看出来struct不仅仅能够将struct作为匿名字段、自定义类型、内置类型都可以作为匿名字段，而且可以在相应的字段上面进行函数操作（如例子中的append）。
-
-这里有一个问题：如果human里面有一个字段叫做phone，而student也有一个字段叫做phone，那么该怎么办呢？
-
-Go里面很简单的解决了这个问题，最外层的优先访问，也就是当你通过`student.phone`访问的时候，是访问student里面的字段，而不是human里面的字段。
-
-这样就允许我们去重载通过匿名字段继承的一些字段，当然如果我们想访问重载后对应匿名类型里面的字段，可以通过匿名字段名来访问。请看下面的例子
-
-	package main
-	import "fmt"
-
-	type Human struct {
-		name string
-		age int
-		phone string  // Human类型拥有的字段
-	}
-
-	type Employee struct {
-		Human  // 匿名字段Human
-		speciality string
-		phone string  // 雇员的phone字段
-	}
-
-	func main() {
-		Bob := Employee{Human{"Bob", 34, "777-444-XXXX"}, "Designer", "333-222"}
-		fmt.Println("Bob's work phone is:", Bob.phone)
-		// 如果我们要访问Human的phone字段
-		fmt.Println("Bob's personal phone is:", Bob.Human.phone)
-	}
-
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [流程和函数](<02.3.md>)
-   * 下一节: [面向对象](<02.5.md>)
+# 2.4 struct类型
+## struct
+Go语言中，也和C或者其他语言一样，我们可以声明新的类型，作为其它类型的属性或字段的容器。例如，我们可以创建一个自定义类型`person`代表一个人的实体。这个实体拥有属性：姓名和年龄。这样的类型我们称之`struct`。如下代码所示:
+
+	type person struct {
+		name string
+		age int
+	}
+看到了吗？声明一个struct如此简单，上面的类型包含有两个字段
+- 一个string类型的字段name，用来保存用户名称这个属性
+- 一个int类型的字段age,用来保存用户年龄这个属性
+
+如何使用struct呢？请看下面的代码
+
+	type person struct {
+		name string
+		age int
+	}
+
+	var P person  // P现在就是person类型的变量了
+
+	P.name = "Astaxie"  // 赋值"Astaxie"给P的name属性.
+	P.age = 25  // 赋值"25"给变量P的age属性
+	fmt.Printf("The person's name is %s", P.name)  // 访问P的name属性.
+除了上面这种P的声明使用之外，还有两种声明使用方式
+
+- 1.按照顺序提供初始化值
+
+		P := person{"Tom", 25}
+
+- 2.通过`field:value`的方式初始化，这样可以任意顺序
+
+	P := person{age:24, name:"Tom"}
+
+下面我们看一个完整的使用struct的例子
+
+	package main
+	import "fmt"
+
+	// 声明一个新的类型
+	type person struct {
+		name string
+		age int
+	}
+
+	// 比较两个人的年龄，返回年龄大的那个人，并且返回年龄差
+	// struct也是传值的
+	func Older(p1, p2 person) (person, int) {
+		if p1.age>p2.age {  // 比较p1和p2这两个人的年龄
+			return p1, p1.age-p2.age
+		}
+		return p2, p2.age-p1.age
+	}
+
+	func main() {
+		var tom person
+
+		// 赋值初始化
+		tom.name, tom.age = "Tom", 18
+
+		// 两个字段都写清楚的初始化
+		bob := person{age:25, name:"Bob"}
+
+		// 按照struct定义顺序初始化值
+		paul := person{"Paul", 43}
+
+		tb_Older, tb_diff := Older(tom, bob)
+		tp_Older, tp_diff := Older(tom, paul)
+		bp_Older, bp_diff := Older(bob, paul)
+
+		fmt.Printf("Of %s and %s, %s is older by %d years\n",
+			tom.name, bob.name, tb_Older.name, tb_diff)
+
+		fmt.Printf("Of %s and %s, %s is older by %d years\n",
+			tom.name, paul.name, tp_Older.name, tp_diff)
+
+		fmt.Printf("Of %s and %s, %s is older by %d years\n",
+			bob.name, paul.name, bp_Older.name, bp_diff)
+	}
+
+### struct的匿名字段
+我们上面介绍了如何定义一个struct，定义的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。
+
+当匿名字段是一个struct的时候，那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。
+
+让我们来看一个例子，让上面说的这些更具体化
+
+	package main
+	import "fmt"
+
+	type Human struct {
+		name string
+		age int
+		weight int
+	}
+
+	type Student struct {
+		Human  // 匿名字段，那么默认Student就包含了Human的所有字段
+		speciality string
+	}
+
+	func main() {
+		// 我们初始化一个学生
+		mark := Student{Human{"Mark", 25, 120}, "Computer Science"}
+
+		// 我们访问相应的字段
+		fmt.Println("His name is ", mark.name)
+		fmt.Println("His age is ", mark.age)
+		fmt.Println("His weight is ", mark.weight)
+		fmt.Println("His speciality is ", mark.speciality)
+		// 修改对应的备注信息
+		mark.speciality = "AI"
+		fmt.Println("Mark changed his speciality")
+		fmt.Println("His speciality is ", mark.speciality)
+		// 修改他的年龄信息
+		fmt.Println("Mark become old")
+		mark.age = 46
+		fmt.Println("His age is", mark.age)
+		// 修改他的体重信息
+		fmt.Println("Mark is not an athlet anymore")
+		mark.weight += 60
+		fmt.Println("His weight is", mark.weight)
+	}
+
+图例如下:
+
+![](images/2.4.student_struct.png?raw=true)
+
+图2.7 Student和Human的方法继承
+
+我们看到Student访问属性age和name的时候，就像访问自己所有用的字段一样，对，匿名字段就是这样，能够实现字段的继承。是不是很酷啊？还有比这个更酷的呢，那就是student还能访问Human这个字段作为字段名。请看下面的代码，是不是更酷了。
+
+	mark.Human = Human{"Marcus", 55, 220}
+	mark.Human.age -= 1
+
+通过匿名访问和修改字段相当的有用，但是不仅仅是struct字段哦，所有的内置类型和自定义类型都是可以作为匿名字段的。请看下面的例子
+
+	package main
+	import "fmt"
+
+	type Skills []string
+
+	type Human struct {
+		name string
+		age int
+		weight int
+	}
+
+	type Student struct {
+		Human  // 匿名字段，struct
+		Skills // 匿名字段，自定义的类型string slice
+		int    // 内置类型作为匿名字段
+		speciality string
+	}
+
+	func main() {
+		// 初始化学生Jane
+		jane := Student{Human:Human{"Jane", 35, 100}, speciality:"Biology"}
+		// 现在我们来访问相应的字段
+		fmt.Println("Her name is ", jane.name)
+		fmt.Println("Her age is ", jane.age)
+		fmt.Println("Her weight is ", jane.weight)
+		fmt.Println("Her speciality is ", jane.speciality)
+		// 我们来修改他的skill技能字段
+		jane.Skills = []string{"anatomy"}
+		fmt.Println("Her skills are ", jane.Skills)
+		fmt.Println("She acquired two new ones ")
+		jane.Skills = append(jane.Skills, "physics", "golang")
+		fmt.Println("Her skills now are ", jane.Skills)
+		// 修改匿名内置类型字段
+		jane.int = 3
+		fmt.Println("Her preferred number is", jane.int)
+	}
+
+从上面例子我们看出来struct不仅仅能够将struct作为匿名字段、自定义类型、内置类型都可以作为匿名字段，而且可以在相应的字段上面进行函数操作（如例子中的append）。
+
+这里有一个问题：如果human里面有一个字段叫做phone，而student也有一个字段叫做phone，那么该怎么办呢？
+
+Go里面很简单的解决了这个问题，最外层的优先访问，也就是当你通过`student.phone`访问的时候，是访问student里面的字段，而不是human里面的字段。
+
+这样就允许我们去重载通过匿名字段继承的一些字段，当然如果我们想访问重载后对应匿名类型里面的字段，可以通过匿名字段名来访问。请看下面的例子
+
+	package main
+	import "fmt"
+
+	type Human struct {
+		name string
+		age int
+		phone string  // Human类型拥有的字段
+	}
+
+	type Employee struct {
+		Human  // 匿名字段Human
+		speciality string
+		phone string  // 雇员的phone字段
+	}
+
+	func main() {
+		Bob := Employee{Human{"Bob", 34, "777-444-XXXX"}, "Designer", "333-222"}
+		fmt.Println("Bob's work phone is:", Bob.phone)
+		// 如果我们要访问Human的phone字段
+		fmt.Println("Bob's personal phone is:", Bob.Human.phone)
+	}
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [流程和函数](<02.3.md>)
+   * 下一节: [面向对象](<02.5.md>)

02.8.md → ebook/02.8.md

-# 2.8 总结
-
-这一章我们主要介绍了Go语言的一些语法，通过语法我们可以发现Go是多么的简单，只有二十五个关键字。让我们再来回顾一下这些关键字都是用来干什么的。
-
-	break    default      func    interface    select
-	case     defer        go      map          struct
-	chan     else         goto    package      switch
-	const    fallthrough  if      range        type
-	continue for          import  return       var
-
-- var和const参考2.2Go语言基础里面的变量和常量申明
-- package和import已经有过短暂的接触
-- func 用于定义函数和方法
-- return 用于从函数返回
-- defer 用于类似析构函数
-- go 用于并行
-- select 用于选择不同类型的通讯
-- interface 用于定义接口，参考2.6小节
-- struct 用于定义抽象数据类型，参考2.5小节
-- break、case、continue、for、fallthrough、else、if、switch、goto、default这些参考2.3流程介绍里面
-- chan用于channel通讯
-- type用于声明自定义类型
-- map用于声明map类型数据
-- range用于读取slice、map、channel数据
-
-上面这二十五个关键字记住了，那么Go你也已经差不多学会了。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [并发](<02.7.md>)
-   * 下一章: [Web基础](<03.0.md>)
+# 2.8 总结
+
+这一章我们主要介绍了Go语言的一些语法，通过语法我们可以发现Go是多么的简单，只有二十五个关键字。让我们再来回顾一下这些关键字都是用来干什么的。
+
+	break    default      func    interface    select
+	case     defer        go      map          struct
+	chan     else         goto    package      switch
+	const    fallthrough  if      range        type
+	continue for          import  return       var
+
+- var和const参考2.2Go语言基础里面的变量和常量申明
+- package和import已经有过短暂的接触
+- func 用于定义函数和方法
+- return 用于从函数返回
+- defer 用于类似析构函数
+- go 用于并行
+- select 用于选择不同类型的通讯
+- interface 用于定义接口，参考2.6小节
+- struct 用于定义抽象数据类型，参考2.5小节
+- break、case、continue、for、fallthrough、else、if、switch、goto、default这些参考2.3流程介绍里面
+- chan用于channel通讯
+- type用于声明自定义类型
+- map用于声明map类型数据
+- range用于读取slice、map、channel数据
+
+上面这二十五个关键字记住了，那么Go你也已经差不多学会了。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [并发](<02.7.md>)
+   * 下一章: [Web基础](<03.0.md>)

03.0.md → ebook/03.0.md

-# 3 Web基础
-
-学习基于Web的编程可能正是你读本书的原因。事实上，如何通过Go来编写Web应用也是我编写这本书的初衷。前面已经介绍过，Go目前已经拥有了成熟的Http处理包，这使得编写能做任何事情的动态Web程序易如反掌。在接下来的各章中将要介绍的内容，都是属于Web编程的范畴。本章则集中讨论一些与Web相关的概念和Go如何运行Web程序的话题。
-
-## 目录
-![](images/navi3.png?raw=true)
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第二章总结](<02.8.md>)
-   * 下一节: [web工作方式](<03.1.md>)
+# 3 Web基础
+
+学习基于Web的编程可能正是你读本书的原因。事实上，如何通过Go来编写Web应用也是我编写这本书的初衷。前面已经介绍过，Go目前已经拥有了成熟的Http处理包，这使得编写能做任何事情的动态Web程序易如反掌。在接下来的各章中将要介绍的内容，都是属于Web编程的范畴。本章则集中讨论一些与Web相关的概念和Go如何运行Web程序的话题。
+
+## 目录
+![](images/navi3.png?raw=true)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第二章总结](<02.8.md>)
+   * 下一节: [web工作方式](<03.1.md>)

03.5.md → ebook/03.5.md

-# 3.5 小结
-这一章我们介绍了HTTP协议, DNS解析的过程, 如何用go实现一个简陋的web server。并深入到net/http包的源码中为大家揭开实现此server的秘密。
-
-希望通过这一章的学习，你能够对Go开发Web有了初步的了解，我们也看到相应的代码了，Go开发Web应用是很方便的，同时又是相当的灵活。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [Go的http包详解](<03.4.md>)
-   * 下一章: [表单](<04.0.md>)
+# 3.5 小结
+这一章我们介绍了HTTP协议, DNS解析的过程, 如何用go实现一个简陋的web server。并深入到net/http包的源码中为大家揭开实现此server的秘密。
+
+希望通过这一章的学习，你能够对Go开发Web有了初步的了解，我们也看到相应的代码了，Go开发Web应用是很方便的，同时又是相当的灵活。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [Go的http包详解](<03.4.md>)
+   * 下一章: [表单](<04.0.md>)

04.0.md → ebook/04.0.md

-# 4 表单
-
-表单是我们平常编写Web应用常用的工具，通过表单我们可以方便的让客户端和服务器进行数据的交互。对于以前开发过Web的用户来说表单都非常熟悉，但是对于C/C++程序员来说，这可能是一个有些陌生的东西，那么什么是表单呢？
-
-表单是一个包含表单元素的区域。表单元素是允许用户在表单中（比如：文本域、下拉列表、单选框、复选框等等）输入信息的元素。表单使用表单标签（\<form\>）定义。
-
-	<form>
-	...
-	input 元素
-	...
-	</form>
-
-Go里面对于form处理已经有很方便的方法了，在Request里面的有专门的form处理，可以很方便的整合到Web开发里面来，4.1小节里面将讲解Go如何处理表单的输入。由于不能信任任何用户的输入，所以我们需要对这些输入进行有效性验证，4.2小节将就如何进行一些普通的验证进行详细的演示。
-
-HTTP协议是一种无状态的协议，那么如何才能辨别是否是同一个用户呢？同时又如何保证一个表单不出现多次递交的情况呢？4.3和4.4小节里面将对cookie(cookie是存储在客户端的信息，能够每次通过header和服务器进行交互的数据)等进行详细讲解。
-
-表单还有一个很大的功能就是能够上传文件，那么Go是如何处理文件上传的呢？针对大文件上传我们如何有效的处理呢？4.5小节我们将一起学习Go处理文件上传的知识。
-
-## 目录
-![](images/navi4.png?raw=true)
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第三章总结](<03.5.md>)
-   * 下一节: [处理表单的输入](<04.1.md>)
+# 4 表单
+
+表单是我们平常编写Web应用常用的工具，通过表单我们可以方便的让客户端和服务器进行数据的交互。对于以前开发过Web的用户来说表单都非常熟悉，但是对于C/C++程序员来说，这可能是一个有些陌生的东西，那么什么是表单呢？
+
+表单是一个包含表单元素的区域。表单元素是允许用户在表单中（比如：文本域、下拉列表、单选框、复选框等等）输入信息的元素。表单使用表单标签（\<form\>）定义。
+
+	<form>
+	...
+	input 元素
+	...
+	</form>
+
+Go里面对于form处理已经有很方便的方法了，在Request里面的有专门的form处理，可以很方便的整合到Web开发里面来，4.1小节里面将讲解Go如何处理表单的输入。由于不能信任任何用户的输入，所以我们需要对这些输入进行有效性验证，4.2小节将就如何进行一些普通的验证进行详细的演示。
+
+HTTP协议是一种无状态的协议，那么如何才能辨别是否是同一个用户呢？同时又如何保证一个表单不出现多次递交的情况呢？4.3和4.4小节里面将对cookie(cookie是存储在客户端的信息，能够每次通过header和服务器进行交互的数据)等进行详细讲解。
+
+表单还有一个很大的功能就是能够上传文件，那么Go是如何处理文件上传的呢？针对大文件上传我们如何有效的处理呢？4.5小节我们将一起学习Go处理文件上传的知识。
+
+## 目录
+![](images/navi4.png?raw=true)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第三章总结](<03.5.md>)
+   * 下一节: [处理表单的输入](<04.1.md>)

04.1.md → ebook/04.1.md

-# 4.1 处理表单的输入
-
-先来看一个表单递交的例子，我们有如下的表单内容，命名成文件login.gtpl(放入当前新建项目的目录里面)
-
-	<html>
-	<head>
-	<title></title>
-	</head>
-	<body>
-	<form action="http://127.0.0.1:9090/login" method="post">
-		用户名:<input type="text" name="username">
-		密码:<input type="password" name="password">
-		<input type="submit" value="登陆">
-	</form>
-	</body>
-	</html>
-
-上面递交表单到服务器的`/login`，当用户输入信息点击登陆之后，会跳转到服务器的路由`login`里面，我们首先要判断这个是什么方式传递过来，POST还是GET呢？
-
-http包里面有一个很简单的方式就可以获取，我们在前面web的例子的基础上来看看怎么处理login页面的form数据
-
-
-	package main
-
-	import (
-		"fmt"
-		"html/template"
-		"log"
-		"net/http"
-		"strings"
-	)
-
-	func sayhelloName(w http.ResponseWriter, r *http.Request) {
-		r.ParseForm()       //解析url传递的参数，对于POST则解析响应包的主体（request body）
-		//注意:如果没有调用ParseForm方法，下面无法获取表单的数据
-		fmt.Println(r.Form) //这些信息是输出到服务器端的打印信息
-		fmt.Println("path", r.URL.Path)
-		fmt.Println("scheme", r.URL.Scheme)
-		fmt.Println(r.Form["url_long"])
-		for k, v := range r.Form {
-			fmt.Println("key:", k)
-			fmt.Println("val:", strings.Join(v, ""))
-		}
-		fmt.Fprintf(w, "Hello astaxie!") //这个写入到w的是输出到客户端的
-	}
-
-	func login(w http.ResponseWriter, r *http.Request) {
-		fmt.Println("method:", r.Method) //获取请求的方法
-		if r.Method == "GET" {
-			t, _ := template.ParseFiles("login.gtpl")
-			t.Execute(w, nil)
-		} else {
-			//请求的是登陆数据，那么执行登陆的逻辑判断
-			fmt.Println("username:", r.Form["username"])
-			fmt.Println("password:", r.Form["password"])
-		}
-	}
-
-	func main() {
-		http.HandleFunc("/", sayhelloName)       //设置访问的路由
-		http.HandleFunc("/login", login)         //设置访问的路由
-		err := http.ListenAndServe(":9090", nil) //设置监听的端口
-		if err != nil {
-			log.Fatal("ListenAndServe: ", err)
-		}
-	}
-
-
-通过上面的代码我们可以看出获取请求方法是通过`r.Method`来完成的，这是个字符串类型的变量，返回GET, POST, PUT等method信息。
-
-login函数中我们根据`r.Method`来判断是显示登录界面还是处理登录逻辑。当GET方式请求时显示登录界面，其他方式请求时则处理登录逻辑，如查询数据库、验证登录信息等。
-
-当我们在浏览器里面打开`http://127.0.0.1:9090/login`的时候，出现如下界面
-
-![](images/4.1.login.png?raw=true)
-
-图4.1 用户登录界面
-
-我们输入用户名和密码之后发现在服务器端是不会打印出来任何输出的，为什么呢？默认情况下，Handler里面是不会自动解析form的，必须显式的调用`r.ParseForm()`后，你才能对这个表单数据进行操作。我们修改一下代码，在`fmt.Println("username:", r.Form["username"])`之前加一行`r.ParseForm()`,重新编译，再次测试输入递交，现在是不是在服务器端有输出你的输入的用户名和密码了。
-
-`r.Form`里面包含了所有请求的参数，比如URL中query-string、POST的数据、PUT的数据，所有当你在URL的query-string字段和POST冲突时，会保存成一个slice，里面存储了多个值，Go官方文档中说在接下来的版本里面将会把POST、GET这些数据分离开来。
-
-现在我们修改一下login.gtpl里面form的action值`http://127.0.0.1:9090/login`修改为`http://127.0.0.1:9090/login?username=astaxie`，再次测试，服务器的输出username是不是一个slice。服务器端的输出如下：
-
-![](images/4.1.slice.png?raw=true)
-
-图4.2 服务器端打印接受到的信息
-
-`request.Form`是一个url.Values类型，里面存储的是对应的类似`key=value`的信息，下面展示了可以对form数据进行的一些操作:
-
-	v := url.Values{}
-	v.Set("name", "Ava")
-	v.Add("friend", "Jess")
-	v.Add("friend", "Sarah")
-	v.Add("friend", "Zoe")
-	// v.Encode() == "name=Ava&friend=Jess&friend=Sarah&friend=Zoe"
-	fmt.Println(v.Get("name"))
-	fmt.Println(v.Get("friend"))
-	fmt.Println(v["friend"])
-
->**Tips**: 
-Request本身也提供了FormValue()函数来获取用户提交的参数。如r.Form["username"]也可写成r.FormValue("username")。调用r.FormValue时会自动调用r.ParseForm，所以不必提前调用。r.FormValue只会返回同名参数中的第一个，若参数不存在则返回空字符串。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [表单](<04.0.md>)
-   * 下一节: [验证表单的输入](<04.2.md>)
+# 4.1 处理表单的输入
+
+先来看一个表单递交的例子，我们有如下的表单内容，命名成文件login.gtpl(放入当前新建项目的目录里面)
+
+	<html>
+	<head>
+	<title></title>
+	</head>
+	<body>
+	<form action="http://127.0.0.1:9090/login" method="post">
+		用户名:<input type="text" name="username">
+		密码:<input type="password" name="password">
+		<input type="submit" value="登陆">
+	</form>
+	</body>
+	</html>
+
+上面递交表单到服务器的`/login`，当用户输入信息点击登陆之后，会跳转到服务器的路由`login`里面，我们首先要判断这个是什么方式传递过来，POST还是GET呢？
+
+http包里面有一个很简单的方式就可以获取，我们在前面web的例子的基础上来看看怎么处理login页面的form数据
+
+
+	package main
+
+	import (
+		"fmt"
+		"html/template"
+		"log"
+		"net/http"
+		"strings"
+	)
+
+	func sayhelloName(w http.ResponseWriter, r *http.Request) {
+		r.ParseForm()       //解析url传递的参数，对于POST则解析响应包的主体（request body）
+		//注意:如果没有调用ParseForm方法，下面无法获取表单的数据
+		fmt.Println(r.Form) //这些信息是输出到服务器端的打印信息
+		fmt.Println("path", r.URL.Path)
+		fmt.Println("scheme", r.URL.Scheme)
+		fmt.Println(r.Form["url_long"])
+		for k, v := range r.Form {
+			fmt.Println("key:", k)
+			fmt.Println("val:", strings.Join(v, ""))
+		}
+		fmt.Fprintf(w, "Hello astaxie!") //这个写入到w的是输出到客户端的
+	}
+
+	func login(w http.ResponseWriter, r *http.Request) {
+		fmt.Println("method:", r.Method) //获取请求的方法
+		if r.Method == "GET" {
+			t, _ := template.ParseFiles("login.gtpl")
+			t.Execute(w, nil)
+		} else {
+			//请求的是登陆数据，那么执行登陆的逻辑判断
+			fmt.Println("username:", r.Form["username"])
+			fmt.Println("password:", r.Form["password"])
+		}
+	}
+
+	func main() {
+		http.HandleFunc("/", sayhelloName)       //设置访问的路由
+		http.HandleFunc("/login", login)         //设置访问的路由
+		err := http.ListenAndServe(":9090", nil) //设置监听的端口
+		if err != nil {
+			log.Fatal("ListenAndServe: ", err)
+		}
+	}
+
+
+通过上面的代码我们可以看出获取请求方法是通过`r.Method`来完成的，这是个字符串类型的变量，返回GET, POST, PUT等method信息。
+
+login函数中我们根据`r.Method`来判断是显示登录界面还是处理登录逻辑。当GET方式请求时显示登录界面，其他方式请求时则处理登录逻辑，如查询数据库、验证登录信息等。
+
+当我们在浏览器里面打开`http://127.0.0.1:9090/login`的时候，出现如下界面
+
+![](images/4.1.login.png?raw=true)
+
+图4.1 用户登录界面
+
+我们输入用户名和密码之后发现在服务器端是不会打印出来任何输出的，为什么呢？默认情况下，Handler里面是不会自动解析form的，必须显式的调用`r.ParseForm()`后，你才能对这个表单数据进行操作。我们修改一下代码，在`fmt.Println("username:", r.Form["username"])`之前加一行`r.ParseForm()`,重新编译，再次测试输入递交，现在是不是在服务器端有输出你的输入的用户名和密码了。
+
+`r.Form`里面包含了所有请求的参数，比如URL中query-string、POST的数据、PUT的数据，所有当你在URL的query-string字段和POST冲突时，会保存成一个slice，里面存储了多个值，Go官方文档中说在接下来的版本里面将会把POST、GET这些数据分离开来。
+
+现在我们修改一下login.gtpl里面form的action值`http://127.0.0.1:9090/login`修改为`http://127.0.0.1:9090/login?username=astaxie`，再次测试，服务器的输出username是不是一个slice。服务器端的输出如下：
+
+![](images/4.1.slice.png?raw=true)
+
+图4.2 服务器端打印接受到的信息
+
+`request.Form`是一个url.Values类型，里面存储的是对应的类似`key=value`的信息，下面展示了可以对form数据进行的一些操作:
+
+	v := url.Values{}
+	v.Set("name", "Ava")
+	v.Add("friend", "Jess")
+	v.Add("friend", "Sarah")
+	v.Add("friend", "Zoe")
+	// v.Encode() == "name=Ava&friend=Jess&friend=Sarah&friend=Zoe"
+	fmt.Println(v.Get("name"))
+	fmt.Println(v.Get("friend"))
+	fmt.Println(v["friend"])
+
+>**Tips**: 
+Request本身也提供了FormValue()函数来获取用户提交的参数。如r.Form["username"]也可写成r.FormValue("username")。调用r.FormValue时会自动调用r.ParseForm，所以不必提前调用。r.FormValue只会返回同名参数中的第一个，若参数不存在则返回空字符串。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [表单](<04.0.md>)
+   * 下一节: [验证表单的输入](<04.2.md>)

04.2.md → ebook/04.2.md

-# 4.2 验证表单的输入
-
-开发Web的一个原则就是，不能信任用户输入的任何信息，所以验证和过滤用户的输入信息就变得非常重要，我们经常会在微博、新闻中听到某某网站被入侵了，存在什么漏洞，这些大多是因为网站对于用户输入的信息没有做严格的验证引起的，所以为了编写出安全可靠的Web程序，验证表单输入的意义重大。
-
-我们平常编写Web应用主要有两方面的数据验证，一个是在页面端的js验证(目前在这方面有很多的插件库，比如ValidationJS插件)，一个是在服务器端的验证，我们这小节讲解的是如何在服务器端验证。
-
-## 必填字段
-你想要确保从一个表单元素中得到一个值，例如前面小节里面的用户名，我们如何处理呢？Go有一个内置函数`len`可以获取字符串的长度，这样我们就可以通过len来获取数据的长度，例如：
-
-	if len(r.Form["username"][0])==0{
-		//为空的处理
-	}
-
-`r.Form`对不同类型的表单元素的留空有不同的处理， 对于空文本框、空文本区域以及文件上传，元素的值为空值,而如果是未选中的复选框和单选按钮，则根本不会在r.Form中产生相应条目，如果我们用上面例子中的方式去获取数据时程序就会报错。所以我们需要通过`r.Form.Get()`来获取值，因为如果字段不存在，通过该方式获取的是空值。但是通过`r.Form.Get()`只能获取单个的值，如果是map的值，必须通过上面的方式来获取。
-
-## 数字
-你想要确保一个表单输入框中获取的只能是数字，例如，你想通过表单获取某个人的具体年龄是50岁还是10岁，而不是像“一把年纪了”或“年轻着呢”这种描述
-
-如果我们是判断正整数，那么我们先转化成int类型，然后进行处理
-
-	getint,err:=strconv.Atoi(r.Form.Get("age"))
-	if err!=nil{
-		//数字转化出错了，那么可能就不是数字
-	}
-
-	//接下来就可以判断这个数字的大小范围了
-	if getint >100 {
-		//太大了
-	}
-
-还有一种方式就是正则匹配的方式
-
-	if m, _ := regexp.MatchString("^[0-9]+$", r.Form.Get("age")); !m {
-		return false
-	}
-
-对于性能要求很高的用户来说，这是一个老生常谈的问题了，他们认为应该尽量避免使用正则表达式，因为使用正则表达式的速度会比较慢。但是在目前机器性能那么强劲的情况下，对于这种简单的正则表达式效率和类型转换函数是没有什么差别的。如果你对正则表达式很熟悉，而且你在其它语言中也在使用它，那么在Go里面使用正则表达式将是一个便利的方式。
-
->Go实现的正则是[RE2](http://code.google.com/p/re2/wiki/Syntax)，所有的字符都是UTF-8编码的。
-
-## 中文
-有时候我们想通过表单元素获取一个用户的中文名字，但是又为了保证获取的是正确的中文，我们需要进行验证，而不是用户随便的一些输入。对于中文我们目前有效的验证只有正则方式来验证，如下代码所示
-
-	if m, _ := regexp.MatchString("^[\\x{4e00}-\\x{9fa5}]+$", r.Form.Get("realname")); !m {
-		return false
-	}
-
-## 英文
-我们期望通过表单元素获取一个英文值，例如我们想知道一个用户的英文名，应该是astaxie，而不是asta谢。
-
-我们可以很简单的通过正则验证数据：
-
-	if m, _ := regexp.MatchString("^[a-zA-Z]+$", r.Form.Get("engname")); !m {
-		return false
-	}
-
-
-## 电子邮件地址
-你想知道用户输入的一个Email地址是否正确，通过如下这个方式可以验证：
-
-	if m, _ := regexp.MatchString(`^([\w\.\_]{2,10})@(\w{1,}).([a-z]{2,4})$`, r.Form.Get("email")); !m {
-		fmt.Println("no")
-	}else{
-		fmt.Println("yes")
-	}
-
-
-## 手机号码
-你想要判断用户输入的手机号码是否正确，通过正则也可以验证：
-
-	if m, _ := regexp.MatchString(`^(1[3|4|5|8][0-9]\d{4,8})$`, r.Form.Get("mobile")); !m {
-		return false
-	}
-
-## 下拉菜单
-如果我们想要判断表单里面`<select>`元素生成的下拉菜单中是否有被选中的项目。有些时候黑客可能会伪造这个下拉菜单不存在的值发送给你，那么如何判断这个值是否是我们预设的值呢？
-
-我们的select可能是这样的一些元素
-
-	<select name="fruit">
-	<option value="apple">apple</option>
-	<option value="pear">pear</option>
-	<option value="banane">banane</option>
-	</select>
-
-那么我们可以这样来验证
-
-	slice:=[]string{"apple","pear","banane"}
-
-	for _, v := range slice {
-		if v == r.Form.Get("fruit") {
-			return true
-		}
-	}
-	return false
-
-上面这个函数包含在我开源的一个库里面(操作slice和map的库)，[https://github.com/astaxie/beeku](https://github.com/astaxie/beeku)
-
-## 单选按钮
-如果我们想要判断radio按钮是否有一个被选中了，我们页面的输出可能就是一个男、女性别的选择，但是也可能一个15岁大的无聊小孩，一手拿着http协议的书，另一只手通过telnet客户端向你的程序在发送请求呢，你设定的性别男值是1，女是2，他给你发送一个3，你的程序会出现异常吗？因此我们也需要像下拉菜单的判断方式类似，判断我们获取的值是我们预设的值，而不是额外的值。
-
-	<input type="radio" name="gender" value="1">男
-	<input type="radio" name="gender" value="2">女
-
-那我们也可以类似下拉菜单的做法一样
-
-	slice:=[]int{1,2}
-
-	for _, v := range slice {
-		if v == r.Form.Get("gender") {
-			return true
-		}
-	}
-	return false
-
-## 复选框
-有一项选择兴趣的复选框，你想确定用户选中的和你提供给用户选择的是同一个类型的数据。
-
-	<input type="checkbox" name="interest" value="football">足球
-	<input type="checkbox" name="interest" value="basketball">篮球
-	<input type="checkbox" name="interest" value="tennis">网球
-
-对于复选框我们的验证和单选有点不一样，因为接收到的数据是一个slice
-
-	slice:=[]string{"football","basketball","tennis"}
-	a:=Slice_diff(r.Form["interest"],slice)
-	if a == nil{
-		return true
-	}
-
-	return false
-
-
-## 日期和时间
-你想确定用户填写的日期或时间是否有效。例如
-，用户在日程表中安排8月份的第45天开会，或者提供未来的某个时间作为生日。
-
-Go里面提供了一个time的处理包，我们可以把用户的输入年月日转化成相应的时间，然后进行逻辑判断
-
-	t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
-	fmt.Printf("Go launched at %s\n", t.Local())
-
-获取time之后我们就可以进行很多时间函数的操作。具体的判断就根据自己的需求调整。
-
-## 身份证号码
-如果我们想验证表单输入的是否是身份证，通过正则也可以方便的验证，但是身份证有15位和18位，我们两个都需要验证
-
-	//验证15位身份证，15位的是全部数字
-	if m, _ := regexp.MatchString(`^(\d{15})$`, r.Form.Get("usercard")); !m {
-		return false
-	}
-
-	//验证18位身份证，18位前17位为数字，最后一位是校验位，可能为数字或字符X。
-	if m, _ := regexp.MatchString(`^(\d{17})([0-9]|X)$`, r.Form.Get("usercard")); !m {
-		return false
-	}
-
-上面列出了我们一些常用的服务器端的表单元素验证，希望通过这个引导入门，能够让你对Go的数据验证有所了解，特别是Go里面的正则处理。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [处理表单的输入](<04.1.md>)
-   * 下一节: [预防跨站脚本](<04.3.md>)
+# 4.2 验证表单的输入
+
+开发Web的一个原则就是，不能信任用户输入的任何信息，所以验证和过滤用户的输入信息就变得非常重要，我们经常会在微博、新闻中听到某某网站被入侵了，存在什么漏洞，这些大多是因为网站对于用户输入的信息没有做严格的验证引起的，所以为了编写出安全可靠的Web程序，验证表单输入的意义重大。
+
+我们平常编写Web应用主要有两方面的数据验证，一个是在页面端的js验证(目前在这方面有很多的插件库，比如ValidationJS插件)，一个是在服务器端的验证，我们这小节讲解的是如何在服务器端验证。
+
+## 必填字段
+你想要确保从一个表单元素中得到一个值，例如前面小节里面的用户名，我们如何处理呢？Go有一个内置函数`len`可以获取字符串的长度，这样我们就可以通过len来获取数据的长度，例如：
+
+	if len(r.Form["username"][0])==0{
+		//为空的处理
+	}
+
+`r.Form`对不同类型的表单元素的留空有不同的处理， 对于空文本框、空文本区域以及文件上传，元素的值为空值,而如果是未选中的复选框和单选按钮，则根本不会在r.Form中产生相应条目，如果我们用上面例子中的方式去获取数据时程序就会报错。所以我们需要通过`r.Form.Get()`来获取值，因为如果字段不存在，通过该方式获取的是空值。但是通过`r.Form.Get()`只能获取单个的值，如果是map的值，必须通过上面的方式来获取。
+
+## 数字
+你想要确保一个表单输入框中获取的只能是数字，例如，你想通过表单获取某个人的具体年龄是50岁还是10岁，而不是像“一把年纪了”或“年轻着呢”这种描述
+
+如果我们是判断正整数，那么我们先转化成int类型，然后进行处理
+
+	getint,err:=strconv.Atoi(r.Form.Get("age"))
+	if err!=nil{
+		//数字转化出错了，那么可能就不是数字
+	}
+
+	//接下来就可以判断这个数字的大小范围了
+	if getint >100 {
+		//太大了
+	}
+
+还有一种方式就是正则匹配的方式
+
+	if m, _ := regexp.MatchString("^[0-9]+$", r.Form.Get("age")); !m {
+		return false
+	}
+
+对于性能要求很高的用户来说，这是一个老生常谈的问题了，他们认为应该尽量避免使用正则表达式，因为使用正则表达式的速度会比较慢。但是在目前机器性能那么强劲的情况下，对于这种简单的正则表达式效率和类型转换函数是没有什么差别的。如果你对正则表达式很熟悉，而且你在其它语言中也在使用它，那么在Go里面使用正则表达式将是一个便利的方式。
+
+>Go实现的正则是[RE2](http://code.google.com/p/re2/wiki/Syntax)，所有的字符都是UTF-8编码的。
+
+## 中文
+有时候我们想通过表单元素获取一个用户的中文名字，但是又为了保证获取的是正确的中文，我们需要进行验证，而不是用户随便的一些输入。对于中文我们目前有效的验证只有正则方式来验证，如下代码所示
+
+	if m, _ := regexp.MatchString("^[\\x{4e00}-\\x{9fa5}]+$", r.Form.Get("realname")); !m {
+		return false
+	}
+
+## 英文
+我们期望通过表单元素获取一个英文值，例如我们想知道一个用户的英文名，应该是astaxie，而不是asta谢。
+
+我们可以很简单的通过正则验证数据：
+
+	if m, _ := regexp.MatchString("^[a-zA-Z]+$", r.Form.Get("engname")); !m {
+		return false
+	}
+
+
+## 电子邮件地址
+你想知道用户输入的一个Email地址是否正确，通过如下这个方式可以验证：
+
+	if m, _ := regexp.MatchString(`^([\w\.\_]{2,10})@(\w{1,}).([a-z]{2,4})$`, r.Form.Get("email")); !m {
+		fmt.Println("no")
+	}else{
+		fmt.Println("yes")
+	}
+
+
+## 手机号码
+你想要判断用户输入的手机号码是否正确，通过正则也可以验证：
+
+	if m, _ := regexp.MatchString(`^(1[3|4|5|8][0-9]\d{4,8})$`, r.Form.Get("mobile")); !m {
+		return false
+	}
+
+## 下拉菜单
+如果我们想要判断表单里面`<select>`元素生成的下拉菜单中是否有被选中的项目。有些时候黑客可能会伪造这个下拉菜单不存在的值发送给你，那么如何判断这个值是否是我们预设的值呢？
+
+我们的select可能是这样的一些元素
+
+	<select name="fruit">
+	<option value="apple">apple</option>
+	<option value="pear">pear</option>
+	<option value="banane">banane</option>
+	</select>
+
+那么我们可以这样来验证
+
+	slice:=[]string{"apple","pear","banane"}
+
+	for _, v := range slice {
+		if v == r.Form.Get("fruit") {
+			return true
+		}
+	}
+	return false
+
+上面这个函数包含在我开源的一个库里面(操作slice和map的库)，[https://github.com/astaxie/beeku](https://github.com/astaxie/beeku)
+
+## 单选按钮
+如果我们想要判断radio按钮是否有一个被选中了，我们页面的输出可能就是一个男、女性别的选择，但是也可能一个15岁大的无聊小孩，一手拿着http协议的书，另一只手通过telnet客户端向你的程序在发送请求呢，你设定的性别男值是1，女是2，他给你发送一个3，你的程序会出现异常吗？因此我们也需要像下拉菜单的判断方式类似，判断我们获取的值是我们预设的值，而不是额外的值。
+
+	<input type="radio" name="gender" value="1">男
+	<input type="radio" name="gender" value="2">女
+
+那我们也可以类似下拉菜单的做法一样
+
+	slice:=[]int{1,2}
+
+	for _, v := range slice {
+		if v == r.Form.Get("gender") {
+			return true
+		}
+	}
+	return false
+
+## 复选框
+有一项选择兴趣的复选框，你想确定用户选中的和你提供给用户选择的是同一个类型的数据。
+
+	<input type="checkbox" name="interest" value="football">足球
+	<input type="checkbox" name="interest" value="basketball">篮球
+	<input type="checkbox" name="interest" value="tennis">网球
+
+对于复选框我们的验证和单选有点不一样，因为接收到的数据是一个slice
+
+	slice:=[]string{"football","basketball","tennis"}
+	a:=Slice_diff(r.Form["interest"],slice)
+	if a == nil{
+		return true
+	}
+
+	return false
+
+
+## 日期和时间
+你想确定用户填写的日期或时间是否有效。例如
+，用户在日程表中安排8月份的第45天开会，或者提供未来的某个时间作为生日。
+
+Go里面提供了一个time的处理包，我们可以把用户的输入年月日转化成相应的时间，然后进行逻辑判断
+
+	t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
+	fmt.Printf("Go launched at %s\n", t.Local())
+
+获取time之后我们就可以进行很多时间函数的操作。具体的判断就根据自己的需求调整。
+
+## 身份证号码
+如果我们想验证表单输入的是否是身份证，通过正则也可以方便的验证，但是身份证有15位和18位，我们两个都需要验证
+
+	//验证15位身份证，15位的是全部数字
+	if m, _ := regexp.MatchString(`^(\d{15})$`, r.Form.Get("usercard")); !m {
+		return false
+	}
+
+	//验证18位身份证，18位前17位为数字，最后一位是校验位，可能为数字或字符X。
+	if m, _ := regexp.MatchString(`^(\d{17})([0-9]|X)$`, r.Form.Get("usercard")); !m {
+		return false
+	}
+
+上面列出了我们一些常用的服务器端的表单元素验证，希望通过这个引导入门，能够让你对Go的数据验证有所了解，特别是Go里面的正则处理。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [处理表单的输入](<04.1.md>)
+   * 下一节: [预防跨站脚本](<04.3.md>)

04.3.md → ebook/04.3.md

-# 4.3 预防跨站脚本
-
-现在的网站包含大量的动态内容以提高用户体验，比过去要复杂得多。所谓动态内容，就是根据用户环境和需要，Web应用程序能够输出相应的内容。动态站点会受到一种名为“跨站脚本攻击”（Cross Site Scripting, 安全专家们通常将其缩写成 XSS）的威胁，而静态站点则完全不受其影响。
-
-攻击者通常会在有漏洞的程序中插入JavaScript、VBScript、 ActiveX或Flash以欺骗用户。一旦得手，他们可以盗取用户帐户信息，修改用户设置，盗取/污染cookie和植入恶意广告等。
-
-对XSS最佳的防护应该结合以下两种方法：一是验证所有输入数据，有效检测攻击(这个我们前面小节已经有过介绍);另一个是对所有输出数据进行适当的处理，以防止任何已成功注入的脚本在浏览器端运行。
-
-那么Go里面是怎么做这个有效防护的呢？Go的html/template里面带有下面几个函数可以帮你转义
-
-- func HTMLEscape(w io.Writer, b []byte)  //把b进行转义之后写到w
-- func HTMLEscapeString(s string) string  //转义s之后返回结果字符串
-- func HTMLEscaper(args ...interface{}) string //支持多个参数一起转义，返回结果字符串
-
-
-我们看4.1小节的例子
-
-	fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("username"))) //输出到服务器端
-	fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("password")))
-	template.HTMLEscape(w, []byte(r.Form.Get("username"))) //输出到客户端
-
-如果我们输入的username是`<script>alert()</script>`,那么我们可以在浏览器上面看到输出如下所示：
-
-![](images/4.3.escape.png?raw=true)
-
-图4.3 Javascript过滤之后的输出
-
-Go的html/template包默认帮你过滤了html标签，但是有时候你只想要输出这个`<script>alert()</script>`看起来正常的信息，该怎么处理？请使用text/template。请看下面的例子：
-
-	import "text/template"
-	...
-	t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`)
-	err = t.ExecuteTemplate(out, "T", "<script>alert('you have been pwned')</script>")
-
-输出
-
-	Hello, <script>alert('you have been pwned')</script>!
-
-或者使用template.HTML类型
-
-	import "html/template"
-	...
-	t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`)
-	err = t.ExecuteTemplate(out, "T", template.HTML("<script>alert('you have been pwned')</script>"))
-
-输出
-
-	Hello, <script>alert('you have been pwned')</script>!
-
-转换成`template.HTML`后，变量的内容也不会被转义
-
-转义的例子：
-
-	import "html/template"
-	...
-	t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`)
-	err = t.ExecuteTemplate(out, "T", "<script>alert('you have been pwned')</script>")
-
-转义之后的输出：
-
-	Hello, &lt;script&gt;alert(&#39;you have been pwned&#39;)&lt;/script&gt;!
-
-
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [验证的输入](<04.2.md>)
-   * 下一节: [防止多次递交表单](<04.4.md>)
+# 4.3 预防跨站脚本
+
+现在的网站包含大量的动态内容以提高用户体验，比过去要复杂得多。所谓动态内容，就是根据用户环境和需要，Web应用程序能够输出相应的内容。动态站点会受到一种名为“跨站脚本攻击”（Cross Site Scripting, 安全专家们通常将其缩写成 XSS）的威胁，而静态站点则完全不受其影响。
+
+攻击者通常会在有漏洞的程序中插入JavaScript、VBScript、 ActiveX或Flash以欺骗用户。一旦得手，他们可以盗取用户帐户信息，修改用户设置，盗取/污染cookie和植入恶意广告等。
+
+对XSS最佳的防护应该结合以下两种方法：一是验证所有输入数据，有效检测攻击(这个我们前面小节已经有过介绍);另一个是对所有输出数据进行适当的处理，以防止任何已成功注入的脚本在浏览器端运行。
+
+那么Go里面是怎么做这个有效防护的呢？Go的html/template里面带有下面几个函数可以帮你转义
+
+- func HTMLEscape(w io.Writer, b []byte)  //把b进行转义之后写到w
+- func HTMLEscapeString(s string) string  //转义s之后返回结果字符串
+- func HTMLEscaper(args ...interface{}) string //支持多个参数一起转义，返回结果字符串
+
+
+我们看4.1小节的例子
+
+	fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("username"))) //输出到服务器端
+	fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("password")))
+	template.HTMLEscape(w, []byte(r.Form.Get("username"))) //输出到客户端
+
+如果我们输入的username是`<script>alert()</script>`,那么我们可以在浏览器上面看到输出如下所示：
+
+![](images/4.3.escape.png?raw=true)
+
+图4.3 Javascript过滤之后的输出
+
+Go的html/template包默认帮你过滤了html标签，但是有时候你只想要输出这个`<script>alert()</script>`看起来正常的信息，该怎么处理？请使用text/template。请看下面的例子：
+
+	import "text/template"
+	...
+	t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`)
+	err = t.ExecuteTemplate(out, "T", "<script>alert('you have been pwned')</script>")
+
+输出
+
+	Hello, <script>alert('you have been pwned')</script>!
+
+或者使用template.HTML类型
+
+	import "html/template"
+	...
+	t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`)
+	err = t.ExecuteTemplate(out, "T", template.HTML("<script>alert('you have been pwned')</script>"))
+
+输出
+
+	Hello, <script>alert('you have been pwned')</script>!
+
+转换成`template.HTML`后，变量的内容也不会被转义
+
+转义的例子：
+
+	import "html/template"
+	...
+	t, err := template.New("foo").Parse(`{{define "T"}}Hello, {{.}}!{{end}}`)
+	err = t.ExecuteTemplate(out, "T", "<script>alert('you have been pwned')</script>")
+
+转义之后的输出：
+
+	Hello, &lt;script&gt;alert(&#39;you have been pwned&#39;)&lt;/script&gt;!
+
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [验证的输入](<04.2.md>)
+   * 下一节: [防止多次递交表单](<04.4.md>)

04.5.md → ebook/04.5.md

-# 4.5 处理文件上传
-你想处理一个由用户上传的文件，比如你正在建设一个类似Instagram的网站，你需要存储用户拍摄的照片。这种需求该如何实现呢？
-
-要使表单能够上传文件，首先第一步就是要添加form的`enctype`属性，`enctype`属性有如下三种情况:
-
-	application/x-www-form-urlencoded   表示在发送前编码所有字符（默认）
-	multipart/form-data	  不对字符编码。在使用包含文件上传控件的表单时，必须使用该值。
-	text/plain	  空格转换为 "+" 加号，但不对特殊字符编码。
-
-所以，表单的html代码应该类似于:
-
-	<html>
-	<head>
-		<title>上传文件</title>
-	</head>
-	<body>
-	<form enctype="multipart/form-data" action="http://127.0.0.1:9090/upload" method="post">
-	  <input type="file" name="uploadfile" />
-	  <input type="hidden" name="token" value="{{.}}"/>
-	  <input type="submit" value="upload" />
-	</form>
-	</body>
-	</html>
-
-在服务器端，我们增加一个handlerFunc:
-
-	http.HandleFunc("/upload", upload)
-
-	// 处理/upload 逻辑
-	func upload(w http.ResponseWriter, r *http.Request) {
-		fmt.Println("method:", r.Method) //获取请求的方法
-		if r.Method == "GET" {
-			crutime := time.Now().Unix()
-			h := md5.New()
-			io.WriteString(h, strconv.FormatInt(crutime, 10))
-			token := fmt.Sprintf("%x", h.Sum(nil))
-
-			t, _ := template.ParseFiles("upload.gtpl")
-			t.Execute(w, token)
-		} else {
-			r.ParseMultipartForm(32 << 20)
-			file, handler, err := r.FormFile("uploadfile")
-			if err != nil {
-				fmt.Println(err)
-				return
-			}
-			defer file.Close()
-			fmt.Fprintf(w, "%v", handler.Header)
-			f, err := os.OpenFile("./test/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
-			if err != nil {
-				fmt.Println(err)
-				return
-			}
-			defer f.Close()
-			io.Copy(f, file)
-		}
-	}
-
-通过上面的代码可以看到，处理文件上传我们需要调用`r.ParseMultipartForm`，里面的参数表示`maxMemory`，调用`ParseMultipartForm`之后，上传的文件存储在`maxMemory`大小的内存里面，如果文件大小超过了`maxMemory`，那么剩下的部分将存储在系统的临时文件中。我们可以通过`r.FormFile`获取上面的文件句柄，然后实例中使用了`io.Copy`来存储文件。
-
->获取其他非文件字段信息的时候就不需要调用`r.ParseForm`，因为在需要的时候Go自动会去调用。而且`ParseMultipartForm`调用一次之后，后面再次调用不会再有效果。
-
-通过上面的实例我们可以看到我们上传文件主要三步处理：
-
-1. 表单中增加enctype="multipart/form-data"
-2. 服务端调用`r.ParseMultipartForm`,把上传的文件存储在内存和临时文件中
-3. 使用`r.FormFile`获取文件句柄，然后对文件进行存储等处理。
-
-文件handler是multipart.FileHeader,里面存储了如下结构信息
-
-	type FileHeader struct {
-		Filename string
-		Header   textproto.MIMEHeader
-		// contains filtered or unexported fields
-	}
-
-我们通过上面的实例代码打印出来上传文件的信息如下
-
-![](images/4.5.upload2.png?raw=true)
-
-图4.5 打印文件上传后服务器端接受的信息
-
-## 客户端上传文件
-
-我们上面的例子演示了如何通过表单上传文件，然后在服务器端处理文件，其实Go支持模拟客户端表单功能支持文件上传，详细用法请看如下示例：
-
-	package main
-
-	import (
-		"bytes"
-		"fmt"
-		"io"
-		"io/ioutil"
-		"mime/multipart"
-		"net/http"
-		"os"
-	)
-
-	func postFile(filename string, targetUrl string) error {
-		bodyBuf := &bytes.Buffer{}
-		bodyWriter := multipart.NewWriter(bodyBuf)
-
-		//关键的一步操作
-		fileWriter, err := bodyWriter.CreateFormFile("uploadfile", filename)
-		if err != nil {
-			fmt.Println("error writing to buffer")
-			return err
-		}
-
-		//打开文件句柄操作
-		fh, err := os.Open(filename)
-		if err != nil {
-			fmt.Println("error opening file")
-			return err
-		}
-
-		//iocopy
-		_, err = io.Copy(fileWriter, fh)
-		if err != nil {
-			return err
-		}
-
-		contentType := bodyWriter.FormDataContentType()
-		bodyWriter.Close()
-
-		resp, err := http.Post(targetUrl, contentType, bodyBuf)
-		if err != nil {
-			return err
-		}
-		defer resp.Body.Close()
-		resp_body, err := ioutil.ReadAll(resp.Body)
-		if err != nil {
-			return err
-		}
-		fmt.Println(resp.Status)
-		fmt.Println(string(resp_body))
-		return nil
-	}
-
-	// sample usage
-	func main() {
-		target_url := "http://localhost:9090/upload"
-		filename := "./astaxie.pdf"
-		postFile(filename, target_url)
-	}
-
-
-上面的例子详细展示了客户端如何向服务器上传一个文件的例子，客户端通过multipart.Write把文件的文本流写入一个缓存中，然后调用http的Post方法把缓存传到服务器。
-
->如果你还有其他普通字段例如username之类的需要同时写入，那么可以调用multipart的WriteField方法写很多其他类似的字段。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [防止多次递交表单](<04.4.md>)
-   * 下一节: [小结](<04.6.md>)
+# 4.5 处理文件上传
+你想处理一个由用户上传的文件，比如你正在建设一个类似Instagram的网站，你需要存储用户拍摄的照片。这种需求该如何实现呢？
+
+要使表单能够上传文件，首先第一步就是要添加form的`enctype`属性，`enctype`属性有如下三种情况:
+
+	application/x-www-form-urlencoded   表示在发送前编码所有字符（默认）
+	multipart/form-data	  不对字符编码。在使用包含文件上传控件的表单时，必须使用该值。
+	text/plain	  空格转换为 "+" 加号，但不对特殊字符编码。
+
+所以，表单的html代码应该类似于:
+
+	<html>
+	<head>
+		<title>上传文件</title>
+	</head>
+	<body>
+	<form enctype="multipart/form-data" action="http://127.0.0.1:9090/upload" method="post">
+	  <input type="file" name="uploadfile" />
+	  <input type="hidden" name="token" value="{{.}}"/>
+	  <input type="submit" value="upload" />
+	</form>
+	</body>
+	</html>
+
+在服务器端，我们增加一个handlerFunc:
+
+	http.HandleFunc("/upload", upload)
+
+	// 处理/upload 逻辑
+	func upload(w http.ResponseWriter, r *http.Request) {
+		fmt.Println("method:", r.Method) //获取请求的方法
+		if r.Method == "GET" {
+			crutime := time.Now().Unix()
+			h := md5.New()
+			io.WriteString(h, strconv.FormatInt(crutime, 10))
+			token := fmt.Sprintf("%x", h.Sum(nil))
+
+			t, _ := template.ParseFiles("upload.gtpl")
+			t.Execute(w, token)
+		} else {
+			r.ParseMultipartForm(32 << 20)
+			file, handler, err := r.FormFile("uploadfile")
+			if err != nil {
+				fmt.Println(err)
+				return
+			}
+			defer file.Close()
+			fmt.Fprintf(w, "%v", handler.Header)
+			f, err := os.OpenFile("./test/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
+			if err != nil {
+				fmt.Println(err)
+				return
+			}
+			defer f.Close()
+			io.Copy(f, file)
+		}
+	}
+
+通过上面的代码可以看到，处理文件上传我们需要调用`r.ParseMultipartForm`，里面的参数表示`maxMemory`，调用`ParseMultipartForm`之后，上传的文件存储在`maxMemory`大小的内存里面，如果文件大小超过了`maxMemory`，那么剩下的部分将存储在系统的临时文件中。我们可以通过`r.FormFile`获取上面的文件句柄，然后实例中使用了`io.Copy`来存储文件。
+
+>获取其他非文件字段信息的时候就不需要调用`r.ParseForm`，因为在需要的时候Go自动会去调用。而且`ParseMultipartForm`调用一次之后，后面再次调用不会再有效果。
+
+通过上面的实例我们可以看到我们上传文件主要三步处理：
+
+1. 表单中增加enctype="multipart/form-data"
+2. 服务端调用`r.ParseMultipartForm`,把上传的文件存储在内存和临时文件中
+3. 使用`r.FormFile`获取文件句柄，然后对文件进行存储等处理。
+
+文件handler是multipart.FileHeader,里面存储了如下结构信息
+
+	type FileHeader struct {
+		Filename string
+		Header   textproto.MIMEHeader
+		// contains filtered or unexported fields
+	}
+
+我们通过上面的实例代码打印出来上传文件的信息如下
+
+![](images/4.5.upload2.png?raw=true)
+
+图4.5 打印文件上传后服务器端接受的信息
+
+## 客户端上传文件
+
+我们上面的例子演示了如何通过表单上传文件，然后在服务器端处理文件，其实Go支持模拟客户端表单功能支持文件上传，详细用法请看如下示例：
+
+	package main
+
+	import (
+		"bytes"
+		"fmt"
+		"io"
+		"io/ioutil"
+		"mime/multipart"
+		"net/http"
+		"os"
+	)
+
+	func postFile(filename string, targetUrl string) error {
+		bodyBuf := &bytes.Buffer{}
+		bodyWriter := multipart.NewWriter(bodyBuf)
+
+		//关键的一步操作
+		fileWriter, err := bodyWriter.CreateFormFile("uploadfile", filename)
+		if err != nil {
+			fmt.Println("error writing to buffer")
+			return err
+		}
+
+		//打开文件句柄操作
+		fh, err := os.Open(filename)
+		if err != nil {
+			fmt.Println("error opening file")
+			return err
+		}
+
+		//iocopy
+		_, err = io.Copy(fileWriter, fh)
+		if err != nil {
+			return err
+		}
+
+		contentType := bodyWriter.FormDataContentType()
+		bodyWriter.Close()
+
+		resp, err := http.Post(targetUrl, contentType, bodyBuf)
+		if err != nil {
+			return err
+		}
+		defer resp.Body.Close()
+		resp_body, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return err
+		}
+		fmt.Println(resp.Status)
+		fmt.Println(string(resp_body))
+		return nil
+	}
+
+	// sample usage
+	func main() {
+		target_url := "http://localhost:9090/upload"
+		filename := "./astaxie.pdf"
+		postFile(filename, target_url)
+	}
+
+
+上面的例子详细展示了客户端如何向服务器上传一个文件的例子，客户端通过multipart.Write把文件的文本流写入一个缓存中，然后调用http的Post方法把缓存传到服务器。
+
+>如果你还有其他普通字段例如username之类的需要同时写入，那么可以调用multipart的WriteField方法写很多其他类似的字段。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [防止多次递交表单](<04.4.md>)
+   * 下一节: [小结](<04.6.md>)

04.6.md → ebook/04.6.md

-# 4.6 小结
-这一章里面我们学习了Go如何处理表单信息，我们通过用户登陆、上传文件的例子展示了Go处理form表单信息及上传文件的手段。但是在处理表单过程中我们需要验证用户输入的信息，考虑到网站安全的重要性，数据过滤就显得相当重要了，因此后面的章节中专门写了一个小节来讲解了不同方面的数据过滤，顺带讲一下Go对字符串的正则处理。
-
-通过这一章能够让你了解客户端和服务器端是如何进行数据上的交互，客户端将数据传递给服务器系统，服务器接受数据又把处理结果反馈给客户端。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [处理文件上传](<04.5.md>)
-   * 下一章: [访问数据库](<05.0.md>)
+# 4.6 小结
+这一章里面我们学习了Go如何处理表单信息，我们通过用户登陆、上传文件的例子展示了Go处理form表单信息及上传文件的手段。但是在处理表单过程中我们需要验证用户输入的信息，考虑到网站安全的重要性，数据过滤就显得相当重要了，因此后面的章节中专门写了一个小节来讲解了不同方面的数据过滤，顺带讲一下Go对字符串的正则处理。
+
+通过这一章能够让你了解客户端和服务器端是如何进行数据上的交互，客户端将数据传递给服务器系统，服务器接受数据又把处理结果反馈给客户端。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [处理文件上传](<04.5.md>)
+   * 下一章: [访问数据库](<05.0.md>)

05.0.md → ebook/05.0.md

-# 5 访问数据库
-对许多Web应用程序而言，数据库都是其核心所在。数据库几乎可以用来存储你想查询和修改的任何信息，比如用户信息、产品目录或者新闻列表等。
-
-Go没有内置的驱动支持任何的数据库，但是Go定义了database/sql接口，用户可以基于驱动接口开发相应数据库的驱动，5.1小节里面介绍Go设计的一些驱动，介绍Go是如何设计数据库驱动接口的。5.2至5.4小节介绍目前使用的比较多的一些关系型数据驱动以及如何使用，5.5小节介绍我自己开发一个ORM库，基于database/sql标准接口开发的，可以兼容几乎所有支持database/sql的数据库驱动，可以方便的使用Go style来进行数据库操作。
-
-目前NOSQL已经成为Web开发的一个潮流，很多应用采用了NOSQL作为数据库，而不是以前的缓存，5.6小节将介绍MongoDB和Redis两种NOSQL数据库。
-
-## 目录
-   ![](images/navi5.png?raw=true)
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第四章总结](<04.6.md>)
-   * 下一节: [database/sql接口](<05.1.md>)
+# 5 访问数据库
+对许多Web应用程序而言，数据库都是其核心所在。数据库几乎可以用来存储你想查询和修改的任何信息，比如用户信息、产品目录或者新闻列表等。
+
+Go没有内置的驱动支持任何的数据库，但是Go定义了database/sql接口，用户可以基于驱动接口开发相应数据库的驱动，5.1小节里面介绍Go设计的一些驱动，介绍Go是如何设计数据库驱动接口的。5.2至5.4小节介绍目前使用的比较多的一些关系型数据驱动以及如何使用，5.5小节介绍我自己开发一个ORM库，基于database/sql标准接口开发的，可以兼容几乎所有支持database/sql的数据库驱动，可以方便的使用Go style来进行数据库操作。
+
+目前NOSQL已经成为Web开发的一个潮流，很多应用采用了NOSQL作为数据库，而不是以前的缓存，5.6小节将介绍MongoDB和Redis两种NOSQL数据库。
+
+## 目录
+   ![](images/navi5.png?raw=true)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第四章总结](<04.6.md>)
+   * 下一节: [database/sql接口](<05.1.md>)

05.1.md → ebook/05.1.md

-# 5.1 database/sql接口
-Go与PHP不同的地方是Go没有官方提供数据库驱动，而是为开发者开发数据库驱动定义了一些标准接口，开发者可以根据定义的接口来开发相应的数据库驱动，这样做有一个好处，只要按照标准接口开发的代码， 以后需要迁移数据库时，不需要任何修改。那么Go都定义了哪些标准接口呢？让我们来详细的分析一下
-
-## sql.Register
-这个存在于database/sql的函数是用来注册数据库驱动的，当第三方开发者开发数据库驱动时，都会实现init函数，在init里面会调用这个`Register(name string, driver driver.Driver)`完成本驱动的注册。
-
-我们来看一下mymysql、sqlite3的驱动里面都是怎么调用的：
-
-	//https://github.com/mattn/go-sqlite3驱动
-	func init() {
-		sql.Register("sqlite3", &SQLiteDriver{})
-	}
-
-	//https://github.com/mikespook/mymysql驱动
-	// Driver automatically registered in database/sql
-	var d = Driver{proto: "tcp", raddr: "127.0.0.1:3306"}
-	func init() {
-		Register("SET NAMES utf8")
-		sql.Register("mymysql", &d)
-	}
-
-我们看到第三方数据库驱动都是通过调用这个函数来注册自己的数据库驱动名称以及相应的driver实现。在database/sql内部通过一个map来存储用户定义的相应驱动。
-
-	var drivers = make(map[string]driver.Driver)
-
-	drivers[name] = driver
-
-因此通过database/sql的注册函数可以同时注册多个数据库驱动，只要不重复。
-
->在我们使用database/sql接口和第三方库的时候经常看到如下:
-
->		import (
->			"database/sql"
->		 	_ "github.com/mattn/go-sqlite3"
->		)
-
->新手都会被这个`_`所迷惑，其实这个就是Go设计的巧妙之处，我们在变量赋值的时候经常看到这个符号，它是用来忽略变量赋值的占位符，那么包引入用到这个符号也是相似的作用，这儿使用`_`的意思是引入后面的包名而不直接使用这个包中定义的函数，变量等资源。
-
->我们在2.3节流程和函数的一节中介绍过init函数的初始化过程，包在引入的时候会自动调用包的init函数以完成对包的初始化。因此，我们引入上面的数据库驱动包之后要手动去调用init函数，然后在init函数里面注册这个数据库驱动，这样我们就可以在接下来的代码中直接使用这个数据库驱动了。
-
-## driver.Driver
-Driver是一个数据库驱动的接口，他定义了一个method： Open(name string)，这个方法返回一个数据库的Conn接口。
-
-	type Driver interface {
-		Open(name string) (Conn, error)
-	}
-
-返回的Conn只能用来进行一次goroutine的操作，也就是说不能把这个Conn应用于Go的多个goroutine里面。如下代码会出现错误
-
-	...
-	go goroutineA (Conn)  //执行查询操作
-	go goroutineB (Conn)  //执行插入操作
-	...
-
-上面这样的代码可能会使Go不知道某个操作究竟是由哪个goroutine发起的,从而导致数据混乱，比如可能会把goroutineA里面执行的查询操作的结果返回给goroutineB从而使B错误地把此结果当成自己执行的插入数据。
-
-第三方驱动都会定义这个函数，它会解析name参数来获取相关数据库的连接信息，解析完成后，它将使用此信息来初始化一个Conn并返回它。
-
-## driver.Conn
-Conn是一个数据库连接的接口定义，他定义了一系列方法，这个Conn只能应用在一个goroutine里面，不能使用在多个goroutine里面，详情请参考上面的说明。
-
-	type Conn interface {
-		Prepare(query string) (Stmt, error)
-		Close() error
-		Begin() (Tx, error)
-	}
-
-Prepare函数返回与当前连接相关的执行Sql语句的准备状态，可以进行查询、删除等操作。
-
-Close函数关闭当前的连接，执行释放连接拥有的资源等清理工作。因为驱动实现了database/sql里面建议的conn pool，所以你不用再去实现缓存conn之类的，这样会容易引起问题。
-
-Begin函数返回一个代表事务处理的Tx，通过它你可以进行查询,更新等操作，或者对事务进行回滚、递交。
-
-## driver.Stmt
-Stmt是一种准备好的状态，和Conn相关联，而且只能应用于一个goroutine中，不能应用于多个goroutine。
-
-	type Stmt interface {
-		Close() error
-		NumInput() int
-		Exec(args []Value) (Result, error)
-		Query(args []Value) (Rows, error)
-	}
-
-Close函数关闭当前的链接状态，但是如果当前正在执行query，query还是有效返回rows数据。
-
-NumInput函数返回当前预留参数的个数，当返回>=0时数据库驱动就会智能检查调用者的参数。当数据库驱动包不知道预留参数的时候，返回-1。
-
-Exec函数执行Prepare准备好的sql，传入参数执行update/insert等操作，返回Result数据
-
-Query函数执行Prepare准备好的sql，传入需要的参数执行select操作，返回Rows结果集
-
-
-## driver.Tx
-事务处理一般就两个过程，递交或者回滚。数据库驱动里面也只需要实现这两个函数就可以
-
-	type Tx interface {
-		Commit() error
-		Rollback() error
-	}
-
-这两个函数一个用来递交一个事务，一个用来回滚事务。
-
-## driver.Execer
-这是一个Conn可选择实现的接口
-
-	type Execer interface {
-		Exec(query string, args []Value) (Result, error)
-	}
-
-如果这个接口没有定义，那么在调用DB.Exec,就会首先调用Prepare返回Stmt，然后执行Stmt的Exec，然后关闭Stmt。
-
-## driver.Result
-这个是执行Update/Insert等操作返回的结果接口定义
-
-	type Result interface {
-		LastInsertId() (int64, error)
-		RowsAffected() (int64, error)
-	}
-
-LastInsertId函数返回由数据库执行插入操作得到的自增ID号。
-
-RowsAffected函数返回query操作影响的数据条目数。
-
-## driver.Rows
-Rows是执行查询返回的结果集接口定义
-
-	type Rows interface {
-		Columns() []string
-		Close() error
-		Next(dest []Value) error
-	}
-
-Columns函数返回查询数据库表的字段信息，这个返回的slice和sql查询的字段一一对应，而不是返回整个表的所有字段。
-
-Close函数用来关闭Rows迭代器。
-
-Next函数用来返回下一条数据，把数据赋值给dest。dest里面的元素必须是driver.Value的值除了string，返回的数据里面所有的string都必须要转换成[]byte。如果最后没数据了，Next函数最后返回io.EOF。
-
-
-## driver.RowsAffected
-RowsAffested其实就是一个int64的别名，但是他实现了Result接口，用来底层实现Result的表示方式
-
-	type RowsAffected int64
-
-	func (RowsAffected) LastInsertId() (int64, error)
-
-	func (v RowsAffected) RowsAffected() (int64, error)
-
-## driver.Value
-Value其实就是一个空接口，他可以容纳任何的数据
-
-	type Value interface{}
-
-drive的Value是驱动必须能够操作的Value，Value要么是nil，要么是下面的任意一种
-
-	int64
-	float64
-	bool
-	[]byte
-	string   [*]除了Rows.Next返回的不能是string.
-	time.Time
-
-## driver.ValueConverter
-ValueConverter接口定义了如何把一个普通的值转化成driver.Value的接口
-
-	type ValueConverter interface {
-		ConvertValue(v interface{}) (Value, error)
-	}
-
-在开发的数据库驱动包里面实现这个接口的函数在很多地方会使用到，这个ValueConverter有很多好处：
-
-- 转化driver.value到数据库表相应的字段，例如int64的数据如何转化成数据库表uint16字段
-- 把数据库查询结果转化成driver.Value值
-- 在scan函数里面如何把dirve.Value值转化成用户定义的值
-
-## driver.Valuer
-Valuer接口定义了返回一个driver.Value的方式
-
-	type Valuer interface {
-		Value() (Value, error)
-	}
-
-很多类型都实现了这个Value方法，用来自身与driver.Value的转化。
-
-通过上面的讲解，你应该对于驱动的开发有了一个基本的了解，一个驱动只要实现了这些接口就能完成增删查改等基本操作了，剩下的就是与相应的数据库进行数据交互等细节问题了，在此不再赘述。
-
-## database/sql
-database/sql在database/sql/driver提供的接口基础上定义了一些更高阶的方法，用以简化数据库操作,同时内部还建议性地实现一个conn pool。
-
-	type DB struct {
-		driver 	 driver.Driver
-		dsn    	 string
-		mu       sync.Mutex // protects freeConn and closed
-		freeConn []driver.Conn
-		closed   bool
-	}
-
-我们可以看到Open函数返回的是DB对象，里面有一个freeConn，它就是那个简易的连接池。它的实现相当简单或者说简陋，就是当执行Db.prepare的时候会`defer db.putConn(ci, err)`,也就是把这个连接放入连接池，每次调用conn的时候会先判断freeConn的长度是否大于0，大于0说明有可以复用的conn，直接拿出来用就是了，如果不大于0，则创建一个conn,然后再返回之。
-
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [访问数据库](<05.0.md>)
-   * 下一节: [使用MySQL数据库](<05.2.md>)
+# 5.1 database/sql接口
+Go与PHP不同的地方是Go没有官方提供数据库驱动，而是为开发者开发数据库驱动定义了一些标准接口，开发者可以根据定义的接口来开发相应的数据库驱动，这样做有一个好处，只要按照标准接口开发的代码， 以后需要迁移数据库时，不需要任何修改。那么Go都定义了哪些标准接口呢？让我们来详细的分析一下
+
+## sql.Register
+这个存在于database/sql的函数是用来注册数据库驱动的，当第三方开发者开发数据库驱动时，都会实现init函数，在init里面会调用这个`Register(name string, driver driver.Driver)`完成本驱动的注册。
+
+我们来看一下mymysql、sqlite3的驱动里面都是怎么调用的：
+
+	//https://github.com/mattn/go-sqlite3驱动
+	func init() {
+		sql.Register("sqlite3", &SQLiteDriver{})
+	}
+
+	//https://github.com/mikespook/mymysql驱动
+	// Driver automatically registered in database/sql
+	var d = Driver{proto: "tcp", raddr: "127.0.0.1:3306"}
+	func init() {
+		Register("SET NAMES utf8")
+		sql.Register("mymysql", &d)
+	}
+
+我们看到第三方数据库驱动都是通过调用这个函数来注册自己的数据库驱动名称以及相应的driver实现。在database/sql内部通过一个map来存储用户定义的相应驱动。
+
+	var drivers = make(map[string]driver.Driver)
+
+	drivers[name] = driver
+
+因此通过database/sql的注册函数可以同时注册多个数据库驱动，只要不重复。
+
+>在我们使用database/sql接口和第三方库的时候经常看到如下:
+
+>		import (
+>			"database/sql"
+>		 	_ "github.com/mattn/go-sqlite3"
+>		)
+
+>新手都会被这个`_`所迷惑，其实这个就是Go设计的巧妙之处，我们在变量赋值的时候经常看到这个符号，它是用来忽略变量赋值的占位符，那么包引入用到这个符号也是相似的作用，这儿使用`_`的意思是引入后面的包名而不直接使用这个包中定义的函数，变量等资源。
+
+>我们在2.3节流程和函数的一节中介绍过init函数的初始化过程，包在引入的时候会自动调用包的init函数以完成对包的初始化。因此，我们引入上面的数据库驱动包之后要手动去调用init函数，然后在init函数里面注册这个数据库驱动，这样我们就可以在接下来的代码中直接使用这个数据库驱动了。
+
+## driver.Driver
+Driver是一个数据库驱动的接口，他定义了一个method： Open(name string)，这个方法返回一个数据库的Conn接口。
+
+	type Driver interface {
+		Open(name string) (Conn, error)
+	}
+
+返回的Conn只能用来进行一次goroutine的操作，也就是说不能把这个Conn应用于Go的多个goroutine里面。如下代码会出现错误
+
+	...
+	go goroutineA (Conn)  //执行查询操作
+	go goroutineB (Conn)  //执行插入操作
+	...
+
+上面这样的代码可能会使Go不知道某个操作究竟是由哪个goroutine发起的,从而导致数据混乱，比如可能会把goroutineA里面执行的查询操作的结果返回给goroutineB从而使B错误地把此结果当成自己执行的插入数据。
+
+第三方驱动都会定义这个函数，它会解析name参数来获取相关数据库的连接信息，解析完成后，它将使用此信息来初始化一个Conn并返回它。
+
+## driver.Conn
+Conn是一个数据库连接的接口定义，他定义了一系列方法，这个Conn只能应用在一个goroutine里面，不能使用在多个goroutine里面，详情请参考上面的说明。
+
+	type Conn interface {
+		Prepare(query string) (Stmt, error)
+		Close() error
+		Begin() (Tx, error)
+	}
+
+Prepare函数返回与当前连接相关的执行Sql语句的准备状态，可以进行查询、删除等操作。
+
+Close函数关闭当前的连接，执行释放连接拥有的资源等清理工作。因为驱动实现了database/sql里面建议的conn pool，所以你不用再去实现缓存conn之类的，这样会容易引起问题。
+
+Begin函数返回一个代表事务处理的Tx，通过它你可以进行查询,更新等操作，或者对事务进行回滚、递交。
+
+## driver.Stmt
+Stmt是一种准备好的状态，和Conn相关联，而且只能应用于一个goroutine中，不能应用于多个goroutine。
+
+	type Stmt interface {
+		Close() error
+		NumInput() int
+		Exec(args []Value) (Result, error)
+		Query(args []Value) (Rows, error)
+	}
+
+Close函数关闭当前的链接状态，但是如果当前正在执行query，query还是有效返回rows数据。
+
+NumInput函数返回当前预留参数的个数，当返回>=0时数据库驱动就会智能检查调用者的参数。当数据库驱动包不知道预留参数的时候，返回-1。
+
+Exec函数执行Prepare准备好的sql，传入参数执行update/insert等操作，返回Result数据
+
+Query函数执行Prepare准备好的sql，传入需要的参数执行select操作，返回Rows结果集
+
+
+## driver.Tx
+事务处理一般就两个过程，递交或者回滚。数据库驱动里面也只需要实现这两个函数就可以
+
+	type Tx interface {
+		Commit() error
+		Rollback() error
+	}
+
+这两个函数一个用来递交一个事务，一个用来回滚事务。
+
+## driver.Execer
+这是一个Conn可选择实现的接口
+
+	type Execer interface {
+		Exec(query string, args []Value) (Result, error)
+	}
+
+如果这个接口没有定义，那么在调用DB.Exec,就会首先调用Prepare返回Stmt，然后执行Stmt的Exec，然后关闭Stmt。
+
+## driver.Result
+这个是执行Update/Insert等操作返回的结果接口定义
+
+	type Result interface {
+		LastInsertId() (int64, error)
+		RowsAffected() (int64, error)
+	}
+
+LastInsertId函数返回由数据库执行插入操作得到的自增ID号。
+
+RowsAffected函数返回query操作影响的数据条目数。
+
+## driver.Rows
+Rows是执行查询返回的结果集接口定义
+
+	type Rows interface {
+		Columns() []string
+		Close() error
+		Next(dest []Value) error
+	}
+
+Columns函数返回查询数据库表的字段信息，这个返回的slice和sql查询的字段一一对应，而不是返回整个表的所有字段。
+
+Close函数用来关闭Rows迭代器。
+
+Next函数用来返回下一条数据，把数据赋值给dest。dest里面的元素必须是driver.Value的值除了string，返回的数据里面所有的string都必须要转换成[]byte。如果最后没数据了，Next函数最后返回io.EOF。
+
+
+## driver.RowsAffected
+RowsAffested其实就是一个int64的别名，但是他实现了Result接口，用来底层实现Result的表示方式
+
+	type RowsAffected int64
+
+	func (RowsAffected) LastInsertId() (int64, error)
+
+	func (v RowsAffected) RowsAffected() (int64, error)
+
+## driver.Value
+Value其实就是一个空接口，他可以容纳任何的数据
+
+	type Value interface{}
+
+drive的Value是驱动必须能够操作的Value，Value要么是nil，要么是下面的任意一种
+
+	int64
+	float64
+	bool
+	[]byte
+	string   [*]除了Rows.Next返回的不能是string.
+	time.Time
+
+## driver.ValueConverter
+ValueConverter接口定义了如何把一个普通的值转化成driver.Value的接口
+
+	type ValueConverter interface {
+		ConvertValue(v interface{}) (Value, error)
+	}
+
+在开发的数据库驱动包里面实现这个接口的函数在很多地方会使用到，这个ValueConverter有很多好处：
+
+- 转化driver.value到数据库表相应的字段，例如int64的数据如何转化成数据库表uint16字段
+- 把数据库查询结果转化成driver.Value值
+- 在scan函数里面如何把dirve.Value值转化成用户定义的值
+
+## driver.Valuer
+Valuer接口定义了返回一个driver.Value的方式
+
+	type Valuer interface {
+		Value() (Value, error)
+	}
+
+很多类型都实现了这个Value方法，用来自身与driver.Value的转化。
+
+通过上面的讲解，你应该对于驱动的开发有了一个基本的了解，一个驱动只要实现了这些接口就能完成增删查改等基本操作了，剩下的就是与相应的数据库进行数据交互等细节问题了，在此不再赘述。
+
+## database/sql
+database/sql在database/sql/driver提供的接口基础上定义了一些更高阶的方法，用以简化数据库操作,同时内部还建议性地实现一个conn pool。
+
+	type DB struct {
+		driver 	 driver.Driver
+		dsn    	 string
+		mu       sync.Mutex // protects freeConn and closed
+		freeConn []driver.Conn
+		closed   bool
+	}
+
+我们可以看到Open函数返回的是DB对象，里面有一个freeConn，它就是那个简易的连接池。它的实现相当简单或者说简陋，就是当执行Db.prepare的时候会`defer db.putConn(ci, err)`,也就是把这个连接放入连接池，每次调用conn的时候会先判断freeConn的长度是否大于0，大于0说明有可以复用的conn，直接拿出来用就是了，如果不大于0，则创建一个conn,然后再返回之。
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [访问数据库](<05.0.md>)
+   * 下一节: [使用MySQL数据库](<05.2.md>)

05.5.md → ebook/05.5.md

-# 5.5 使用beedb库进行ORM开发
-beedb是我开发的一个Go进行ORM操作的库，它采用了Go style方式对数据库进行操作，实现了struct到数据表记录的映射。beedb是一个十分轻量级的Go ORM框架，开发这个库的本意降低复杂的ORM学习曲线，尽可能在ORM的运行效率和功能之间寻求一个平衡，beedb是目前开源的Go ORM框架中实现比较完整的一个库，而且运行效率相当不错，功能也基本能满足需求。但是目前还不支持关系关联，这个是接下来版本升级的重点。
-
-beedb是支持database/sql标准接口的ORM库，所以理论上来说，只要数据库驱动支持database/sql接口就可以无缝的接入beedb。目前我测试过的驱动包括下面几个：
-
-Mysql:github.com/ziutek/mymysql/godrv[*]
-
-Mysql:code.google.com/p/go-mysql-driver[*]
-
-PostgreSQL:github.com/bmizerany/pq[*]
-
-SQLite:github.com/mattn/go-sqlite3[*]
-
-MS ADODB: github.com/mattn/go-adodb[*]
-
-ODBC: bitbucket.org/miquella/mgodbc[*]
-
-## 安装
-
-beedb支持go get方式安装，是完全按照Go Style的方式来实现的。
-
-	go get github.com/astaxie/beedb
-
-## 如何初始化
-首先你需要import相应的数据库驱动包、database/sql标准接口包以及beedb包，如下所示：
-
-	import (
-		"database/sql"
-		"github.com/astaxie/beedb"
-		_ "github.com/ziutek/mymysql/godrv"
-	)
-
-导入必须的package之后,我们需要打开到数据库的链接，然后创建一个beedb对象（以MySQL为例)，如下所示
-
-	db, err := sql.Open("mymysql", "test/xiemengjun/123456")
-	if err != nil {
-		panic(err)
-	}
-	orm := beedb.New(db)
-
-beedb的New函数实际上应该有两个参数，第一个参数标准接口的db，第二个参数是使用的数据库引擎，如果你使用的数据库引擎是MySQL/Sqlite,那么第二个参数都可以省略。
-
-如果你使用的数据库是SQLServer，那么初始化需要：
-
-	orm = beedb.New(db, "mssql")
-
-如果你使用了PostgreSQL，那么初始化需要：
-
-	orm = beedb.New(db, "pg")
-
-目前beedb支持打印调试，你可以通过如下的代码实现调试
-
-	beedb.OnDebug=true
-
-接下来我们的例子采用前面的数据库表Userinfo，现在我们建立相应的struct
-
-	type Userinfo struct {
-		Uid     int `PK` //如果表的主键不是id，那么需要加上pk注释，显式的说这个字段是主键
-		Username    string
-		Departname  string
-		Created     time.Time
-	}
-
->注意一点，beedb针对驼峰命名会自动帮你转化成下划线字段，例如你定义了Struct名字为`UserInfo`，那么转化成底层实现的时候是`user_info`，字段命名也遵循该规则。
-
-## 插入数据
-下面的代码演示了如何插入一条记录，可以看到我们操作的是strcut对象，而不是原生的sql语句，最后通过调用Save接口将数据保存到数据库。
-
-	var saveone Userinfo
-	saveone.Username = "Test Add User"
-	saveone.Departname = "Test Add Departname"
-	saveone.Created = time.Now()
-	orm.Save(&saveone)
-
-我们看到插入之后`saveone.Uid`就是插入成功之后的自增ID。Save接口会自动帮你存进去。
-
-beedb接口提供了另外一种插入的方式，map数据插入。
-
-	add := make(map[string]interface{})
-	add["username"] = "astaxie"
-	add["departname"] = "cloud develop"
-	add["created"] = "2012-12-02"
-	orm.SetTable("userinfo").Insert(add)
-
-插入多条数据
-
-	addslice := make([]map[string]interface{})
-	add:=make(map[string]interface{})
-	add2:=make(map[string]interface{})
-	add["username"] = "astaxie"
-	add["departname"] = "cloud develop"
-	add["created"] = "2012-12-02"
-	add2["username"] = "astaxie2"
-	add2["departname"] = "cloud develop2"
-	add2["created"] = "2012-12-02"
-	addslice =append(addslice, add, add2)
-	orm.SetTable("userinfo").Insert(addslice)
-
-上面的操作方式有点类似链式查询，熟悉jquery的同学应该会觉得很亲切，每次调用的method都会返回原orm对象，以便可以继续调用该对象上的其他method。
-
-上面我们调用的SetTable函数是显式的告诉ORM，我要执行的这个map对应的数据库表是`userinfo`。
-
-## 更新数据
-继续上面的例子来演示更新操作，现在saveone的主键已经有值了，此时调用save接口，beedb内部会自动调用update以进行数据的更新而非插入操作。
-
-	saveone.Username = "Update Username"
-	saveone.Departname = "Update Departname"
-	saveone.Created = time.Now()
-	orm.Save(&saveone)  //现在saveone有了主键值，就执行更新操作
-
-更新数据也支持直接使用map操作
-
-	t := make(map[string]interface{})
-	t["username"] = "astaxie"
-	orm.SetTable("userinfo").SetPK("uid").Where(2).Update(t)
-
-这里我们调用了几个beedb的函数
-
-SetPK：显式的告诉ORM，数据库表`userinfo`的主键是`uid`。
-
-Where:用来设置条件，支持多个参数，第一个参数如果为整数，相当于调用了Where("主键=?",值)。
-Updata函数接收map类型的数据，执行更新数据。
-
-## 查询数据
-beedb的查询接口比较灵活，具体使用请看下面的例子
-
-例子1，根据主键获取数据：
-
-	var user Userinfo
-	//Where接受两个参数，支持整形参数
-	orm.Where("uid=?", 27).Find(&user)
-
-
-例子2：
-
-	var user2 Userinfo
-	orm.Where(3).Find(&user2) // 这是上面版本的缩写版，可以省略主键
-
-例子3，不是主键类型的的条件：
-
-	var user3 Userinfo
-	//Where接受两个参数，支持字符型的参数
-	orm.Where("name	 = ?", "john").Find(&user3)
-例子4，更加复杂的条件：
-
-	var user4 Userinfo
-	//Where支持三个参数
-	orm.Where("name = ? and age < ?", "john", 88).Find(&user4)
-
-
-可以通过如下接口获取多条数据，请看示例
-
-例子1，根据条件id>3，获取20位置开始的10条数据的数据
-
-	var allusers []Userinfo
-	err := orm.Where("id > ?", "3").Limit(10,20).FindAll(&allusers)
-
-例子2，省略limit第二个参数，默认从0开始，获取10条数据
-
-	var tenusers []Userinfo
-	err := orm.Where("id > ?", "3").Limit(10).FindAll(&tenusers)
-
-例子3，获取全部数据
-
-	var everyone []Userinfo
-	err := orm.OrderBy("uid desc,username asc").FindAll(&everyone)
-
-上面这些里面里面我们看到一个函数Limit，他是用来控制查询结构条数的。
-
-Limit:支持两个参数，第一个参数表示查询的条数，第二个参数表示读取数据的起始位置，默认为0。
-
-OrderBy:这个函数用来进行查询排序，参数是需要排序的条件。
-
-上面这些例子都是将获取的的数据直接映射成struct对象，如果我们只是想获取一些数据到map，以下方式可以实现：
-
-	a, _ := orm.SetTable("userinfo").SetPK("uid").Where(2).Select("uid,username").FindMap()
-
-上面和这个例子里面又出现了一个新的接口函数Select，这个函数用来指定需要查询多少个字段。默认为全部字段`*`。
-
-FindMap()函数返回的是`[]map[string][]byte`类型，所以你需要自己作类型转换。
-
-## 删除数据
-beedb提供了丰富的删除数据接口，请看下面的例子
-
-例子1，删除单条数据
-
-	//saveone就是上面示例中的那个saveone
-	orm.Delete(&saveone)
-
-例子2，删除多条数据
-
-	//alluser就是上面定义的获取多条数据的slice
-	orm.DeleteAll(&alluser)
-
-例子3，根据sql删除数据
-
-	orm.SetTable("userinfo").Where("uid>?", 3).DeleteRow()
-
-
-## 关联查询
-目前beedb还不支持struct的关联关系，但是有些应用却需要用到连接查询，所以现在beedb提供了一个简陋的实现方案：
-
-	a, _ := orm.SetTable("userinfo").Join("LEFT", "userdeatail", "userinfo.uid=userdeatail.uid").Where("userinfo.uid=?", 1).Select("userinfo.uid,userinfo.username,userdeatail.profile").FindMap()
-
-上面代码中我们看到了一个新的接口Join函数，这个函数带有三个参数
-
-- 第一个参数可以是：INNER, LEFT, OUTER, CROSS等
-- 第二个参数表示连接的表
-- 第三个参数表示连接的条件
-
-
-## Group By和Having
-针对有些应用需要用到group by和having的功能，beedb也提供了一个简陋的实现
-
-	a, _ := orm.SetTable("userinfo").GroupBy("username").Having("username='astaxie'").FindMap()
-
-上面的代码中出现了两个新接口函数
-
-GroupBy:用来指定进行groupby的字段
-
-Having:用来指定having执行的时候的条件
-
-## 进一步的发展
-目前beedb已经获得了很多来自国内外用户的反馈，我目前也正在考虑重构，接下来会在几个方面进行改进
-
-- 实现interface设计，类似databse/sql/driver的设计，设计beedb的接口，然后去实现相应数据库的CRUD操作
-- 实现关联数据库设计，支持一对一，一对多，多对多的实现，示例代码如下：
-
-
-	type Profile struct{
-		Nickname	string
-		Mobile		string
-	}
-
-	type Userinfo struct {
-		Uid     int `PK`
-		Username    string
-		Departname  string
-		Created     time.Time
-		Profile     `HasOne`
-	}
-
-- 自动建库建表建索引
-- 实现连接池的实现，采用goroutine
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [使用PostgreSQL数据库](<05.4.md>)
-   * 下一节: [NOSQL数据库操作](<05.6.md>)
+# 5.5 使用beedb库进行ORM开发
+beedb是我开发的一个Go进行ORM操作的库，它采用了Go style方式对数据库进行操作，实现了struct到数据表记录的映射。beedb是一个十分轻量级的Go ORM框架，开发这个库的本意降低复杂的ORM学习曲线，尽可能在ORM的运行效率和功能之间寻求一个平衡，beedb是目前开源的Go ORM框架中实现比较完整的一个库，而且运行效率相当不错，功能也基本能满足需求。但是目前还不支持关系关联，这个是接下来版本升级的重点。
+
+beedb是支持database/sql标准接口的ORM库，所以理论上来说，只要数据库驱动支持database/sql接口就可以无缝的接入beedb。目前我测试过的驱动包括下面几个：
+
+Mysql:github.com/ziutek/mymysql/godrv[*]
+
+Mysql:code.google.com/p/go-mysql-driver[*]
+
+PostgreSQL:github.com/bmizerany/pq[*]
+
+SQLite:github.com/mattn/go-sqlite3[*]
+
+MS ADODB: github.com/mattn/go-adodb[*]
+
+ODBC: bitbucket.org/miquella/mgodbc[*]
+
+## 安装
+
+beedb支持go get方式安装，是完全按照Go Style的方式来实现的。
+
+	go get github.com/astaxie/beedb
+
+## 如何初始化
+首先你需要import相应的数据库驱动包、database/sql标准接口包以及beedb包，如下所示：
+
+	import (
+		"database/sql"
+		"github.com/astaxie/beedb"
+		_ "github.com/ziutek/mymysql/godrv"
+	)
+
+导入必须的package之后,我们需要打开到数据库的链接，然后创建一个beedb对象（以MySQL为例)，如下所示
+
+	db, err := sql.Open("mymysql", "test/xiemengjun/123456")
+	if err != nil {
+		panic(err)
+	}
+	orm := beedb.New(db)
+
+beedb的New函数实际上应该有两个参数，第一个参数标准接口的db，第二个参数是使用的数据库引擎，如果你使用的数据库引擎是MySQL/Sqlite,那么第二个参数都可以省略。
+
+如果你使用的数据库是SQLServer，那么初始化需要：
+
+	orm = beedb.New(db, "mssql")
+
+如果你使用了PostgreSQL，那么初始化需要：
+
+	orm = beedb.New(db, "pg")
+
+目前beedb支持打印调试，你可以通过如下的代码实现调试
+
+	beedb.OnDebug=true
+
+接下来我们的例子采用前面的数据库表Userinfo，现在我们建立相应的struct
+
+	type Userinfo struct {
+		Uid     int `PK` //如果表的主键不是id，那么需要加上pk注释，显式的说这个字段是主键
+		Username    string
+		Departname  string
+		Created     time.Time
+	}
+
+>注意一点，beedb针对驼峰命名会自动帮你转化成下划线字段，例如你定义了Struct名字为`UserInfo`，那么转化成底层实现的时候是`user_info`，字段命名也遵循该规则。
+
+## 插入数据
+下面的代码演示了如何插入一条记录，可以看到我们操作的是strcut对象，而不是原生的sql语句，最后通过调用Save接口将数据保存到数据库。
+
+	var saveone Userinfo
+	saveone.Username = "Test Add User"
+	saveone.Departname = "Test Add Departname"
+	saveone.Created = time.Now()
+	orm.Save(&saveone)
+
+我们看到插入之后`saveone.Uid`就是插入成功之后的自增ID。Save接口会自动帮你存进去。
+
+beedb接口提供了另外一种插入的方式，map数据插入。
+
+	add := make(map[string]interface{})
+	add["username"] = "astaxie"
+	add["departname"] = "cloud develop"
+	add["created"] = "2012-12-02"
+	orm.SetTable("userinfo").Insert(add)
+
+插入多条数据
+
+	addslice := make([]map[string]interface{})
+	add:=make(map[string]interface{})
+	add2:=make(map[string]interface{})
+	add["username"] = "astaxie"
+	add["departname"] = "cloud develop"
+	add["created"] = "2012-12-02"
+	add2["username"] = "astaxie2"
+	add2["departname"] = "cloud develop2"
+	add2["created"] = "2012-12-02"
+	addslice =append(addslice, add, add2)
+	orm.SetTable("userinfo").Insert(addslice)
+
+上面的操作方式有点类似链式查询，熟悉jquery的同学应该会觉得很亲切，每次调用的method都会返回原orm对象，以便可以继续调用该对象上的其他method。
+
+上面我们调用的SetTable函数是显式的告诉ORM，我要执行的这个map对应的数据库表是`userinfo`。
+
+## 更新数据
+继续上面的例子来演示更新操作，现在saveone的主键已经有值了，此时调用save接口，beedb内部会自动调用update以进行数据的更新而非插入操作。
+
+	saveone.Username = "Update Username"
+	saveone.Departname = "Update Departname"
+	saveone.Created = time.Now()
+	orm.Save(&saveone)  //现在saveone有了主键值，就执行更新操作
+
+更新数据也支持直接使用map操作
+
+	t := make(map[string]interface{})
+	t["username"] = "astaxie"
+	orm.SetTable("userinfo").SetPK("uid").Where(2).Update(t)
+
+这里我们调用了几个beedb的函数
+
+SetPK：显式的告诉ORM，数据库表`userinfo`的主键是`uid`。
+
+Where:用来设置条件，支持多个参数，第一个参数如果为整数，相当于调用了Where("主键=?",值)。
+Updata函数接收map类型的数据，执行更新数据。
+
+## 查询数据
+beedb的查询接口比较灵活，具体使用请看下面的例子
+
+例子1，根据主键获取数据：
+
+	var user Userinfo
+	//Where接受两个参数，支持整形参数
+	orm.Where("uid=?", 27).Find(&user)
+
+
+例子2：
+
+	var user2 Userinfo
+	orm.Where(3).Find(&user2) // 这是上面版本的缩写版，可以省略主键
+
+例子3，不是主键类型的的条件：
+
+	var user3 Userinfo
+	//Where接受两个参数，支持字符型的参数
+	orm.Where("name	 = ?", "john").Find(&user3)
+例子4，更加复杂的条件：
+
+	var user4 Userinfo
+	//Where支持三个参数
+	orm.Where("name = ? and age < ?", "john", 88).Find(&user4)
+
+
+可以通过如下接口获取多条数据，请看示例
+
+例子1，根据条件id>3，获取20位置开始的10条数据的数据
+
+	var allusers []Userinfo
+	err := orm.Where("id > ?", "3").Limit(10,20).FindAll(&allusers)
+
+例子2，省略limit第二个参数，默认从0开始，获取10条数据
+
+	var tenusers []Userinfo
+	err := orm.Where("id > ?", "3").Limit(10).FindAll(&tenusers)
+
+例子3，获取全部数据
+
+	var everyone []Userinfo
+	err := orm.OrderBy("uid desc,username asc").FindAll(&everyone)
+
+上面这些里面里面我们看到一个函数Limit，他是用来控制查询结构条数的。
+
+Limit:支持两个参数，第一个参数表示查询的条数，第二个参数表示读取数据的起始位置，默认为0。
+
+OrderBy:这个函数用来进行查询排序，参数是需要排序的条件。
+
+上面这些例子都是将获取的的数据直接映射成struct对象，如果我们只是想获取一些数据到map，以下方式可以实现：
+
+	a, _ := orm.SetTable("userinfo").SetPK("uid").Where(2).Select("uid,username").FindMap()
+
+上面和这个例子里面又出现了一个新的接口函数Select，这个函数用来指定需要查询多少个字段。默认为全部字段`*`。
+
+FindMap()函数返回的是`[]map[string][]byte`类型，所以你需要自己作类型转换。
+
+## 删除数据
+beedb提供了丰富的删除数据接口，请看下面的例子
+
+例子1，删除单条数据
+
+	//saveone就是上面示例中的那个saveone
+	orm.Delete(&saveone)
+
+例子2，删除多条数据
+
+	//alluser就是上面定义的获取多条数据的slice
+	orm.DeleteAll(&alluser)
+
+例子3，根据sql删除数据
+
+	orm.SetTable("userinfo").Where("uid>?", 3).DeleteRow()
+
+
+## 关联查询
+目前beedb还不支持struct的关联关系，但是有些应用却需要用到连接查询，所以现在beedb提供了一个简陋的实现方案：
+
+	a, _ := orm.SetTable("userinfo").Join("LEFT", "userdeatail", "userinfo.uid=userdeatail.uid").Where("userinfo.uid=?", 1).Select("userinfo.uid,userinfo.username,userdeatail.profile").FindMap()
+
+上面代码中我们看到了一个新的接口Join函数，这个函数带有三个参数
+
+- 第一个参数可以是：INNER, LEFT, OUTER, CROSS等
+- 第二个参数表示连接的表
+- 第三个参数表示连接的条件
+
+
+## Group By和Having
+针对有些应用需要用到group by和having的功能，beedb也提供了一个简陋的实现
+
+	a, _ := orm.SetTable("userinfo").GroupBy("username").Having("username='astaxie'").FindMap()
+
+上面的代码中出现了两个新接口函数
+
+GroupBy:用来指定进行groupby的字段
+
+Having:用来指定having执行的时候的条件
+
+## 进一步的发展
+目前beedb已经获得了很多来自国内外用户的反馈，我目前也正在考虑重构，接下来会在几个方面进行改进
+
+- 实现interface设计，类似databse/sql/driver的设计，设计beedb的接口，然后去实现相应数据库的CRUD操作
+- 实现关联数据库设计，支持一对一，一对多，多对多的实现，示例代码如下：
+
+
+	type Profile struct{
+		Nickname	string
+		Mobile		string
+	}
+
+	type Userinfo struct {
+		Uid     int `PK`
+		Username    string
+		Departname  string
+		Created     time.Time
+		Profile     `HasOne`
+	}
+
+- 自动建库建表建索引
+- 实现连接池的实现，采用goroutine
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [使用PostgreSQL数据库](<05.4.md>)
+   * 下一节: [NOSQL数据库操作](<05.6.md>)

05.6.md → ebook/05.6.md

-# 5.6 NOSQL数据库操作
-NoSQL(Not Only SQL)，指的是非关系型的数据库。随着Web2.0的兴起，传统的关系数据库在应付Web2.0网站，特别是超大规模和高并发的SNS类型的Web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。
-
-而Go语言作为21世纪的C语言，对NOSQL的支持也是很好，目前流行的NOSQL主要有redis、mongoDB、Cassandra和Membase等。这些数据库都有高性能、高并发读写等特点，目前已经广泛应用于各种应用中。我接下来主要讲解一下redis和mongoDB的操作。
-
-## redis
-redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。
-
-目前应用redis最广泛的应该是新浪微博平台，其次还有Facebook收购的图片社交网站instagram。以及其他一些有名的[互联网企业](http://redis.io/topics/whos-using-redis)
-
-Go目前支持redis的驱动有如下
-- https://github.com/alphazero/Go-Redis
-- http://code.google.com/p/tideland-rdc/
-- https://github.com/simonz05/godis
-- https://github.com/hoisie/redis.go
-
-目前我fork了最后一个驱动，更新了一些bug，目前应用在我自己的短域名服务项目中(每天200W左右的PV值)
-
-https://github.com/astaxie/goredis
-
-接下来的以我自己fork的这个redis驱动为例来演示如何进行数据的操作
-
-	package main
-
-	import (
-		"github.com/astaxie/goredis"
-		"fmt"
-	)
-
-	func main() {
-		var client goredis.Client
-		//字符串操作
-		var client goredis.Client
-		client.Set("a", []byte("hello"))
-		val, _ := client.Get("a")
-		fmt.Println(string(val))
-		client.Del("a")
-
-		//list操作
-
-		var client goredis.Client
-		vals := []string{"a", "b", "c", "d", "e"}
-		for _, v := range vals {
-			client.Rpush("l", []byte(v))
-		}
-		dbvals,_ := client.Lrange("l", 0, 4)
-		for i, v := range dbvals {
-			println(i,":",string(v))
-		}
-		client.Del("l")
-	}
-
-我们可以看到操作redis非常的方便，而且我实际项目中应用下来性能也很高。client的命令和redis的命令基本保持一致。所以和原生态操作redis非常类似。
-
-## mongoDB
-
-MongoDB是一个高性能，开源，无模式的文档型数据库，是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，采用的是类似json的bjson格式来存储数据，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。
-
-下图展示了mysql和mongoDB之间的对应关系，我们可以看出来非常的方便，但是mongoDB的性能非常好。
-
-![](images/5.6.mongodb.png?raw=true)
-
-图5.1 MongoDB和Mysql的操作对比图
-
-目前Go支持mongoDB最好的驱动就是[mgo](http://labix.org/mgo)，这个驱动目前最有可能成为官方的pkg。
-
-下面我将演示如何通过Go来操作mongoDB：
-
-	package main
-
-	import (
-		"fmt"
-		"labix.org/v2/mgo"
-		"labix.org/v2/mgo/bson"
-	)
-
-	type Person struct {
-		Name string
-		Phone string
-	}
-
-	func main() {
-		session, err := mgo.Dial("server1.example.com,server2.example.com")
-		if err != nil {
-			panic(err)
-		}
-		defer session.Close()
-
-		session.SetMode(mgo.Monotonic, true)
-
-		c := session.DB("test").C("people")
-		err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
-			&Person{"Cla", "+55 53 8402 8510"})
-		if err != nil {
-			panic(err)
-		}
-
-		result := Person{}
-		err = c.Find(bson.M{"name": "Ale"}).One(&result)
-		if err != nil {
-			panic(err)
-		}
-
-		fmt.Println("Phone:", result.Phone)
-	}
-
-我们可以看出来mgo的操作方式和beedb的操作方式几乎类似，都是基于strcut的操作方式，这个就是Go Style。
-
-
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [使用beedb库进行ORM开发](<05.5.md>)
-   * 下一节: [小结](<05.7.md>)
+# 5.6 NOSQL数据库操作
+NoSQL(Not Only SQL)，指的是非关系型的数据库。随着Web2.0的兴起，传统的关系数据库在应付Web2.0网站，特别是超大规模和高并发的SNS类型的Web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。
+
+而Go语言作为21世纪的C语言，对NOSQL的支持也是很好，目前流行的NOSQL主要有redis、mongoDB、Cassandra和Membase等。这些数据库都有高性能、高并发读写等特点，目前已经广泛应用于各种应用中。我接下来主要讲解一下redis和mongoDB的操作。
+
+## redis
+redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。
+
+目前应用redis最广泛的应该是新浪微博平台，其次还有Facebook收购的图片社交网站instagram。以及其他一些有名的[互联网企业](http://redis.io/topics/whos-using-redis)
+
+Go目前支持redis的驱动有如下
+- https://github.com/alphazero/Go-Redis
+- http://code.google.com/p/tideland-rdc/
+- https://github.com/simonz05/godis
+- https://github.com/hoisie/redis.go
+
+目前我fork了最后一个驱动，更新了一些bug，目前应用在我自己的短域名服务项目中(每天200W左右的PV值)
+
+https://github.com/astaxie/goredis
+
+接下来的以我自己fork的这个redis驱动为例来演示如何进行数据的操作
+
+	package main
+
+	import (
+		"github.com/astaxie/goredis"
+		"fmt"
+	)
+
+	func main() {
+		var client goredis.Client
+		//字符串操作
+		var client goredis.Client
+		client.Set("a", []byte("hello"))
+		val, _ := client.Get("a")
+		fmt.Println(string(val))
+		client.Del("a")
+
+		//list操作
+
+		var client goredis.Client
+		vals := []string{"a", "b", "c", "d", "e"}
+		for _, v := range vals {
+			client.Rpush("l", []byte(v))
+		}
+		dbvals,_ := client.Lrange("l", 0, 4)
+		for i, v := range dbvals {
+			println(i,":",string(v))
+		}
+		client.Del("l")
+	}
+
+我们可以看到操作redis非常的方便，而且我实际项目中应用下来性能也很高。client的命令和redis的命令基本保持一致。所以和原生态操作redis非常类似。
+
+## mongoDB
+
+MongoDB是一个高性能，开源，无模式的文档型数据库，是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，采用的是类似json的bjson格式来存储数据，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。
+
+下图展示了mysql和mongoDB之间的对应关系，我们可以看出来非常的方便，但是mongoDB的性能非常好。
+
+![](images/5.6.mongodb.png?raw=true)
+
+图5.1 MongoDB和Mysql的操作对比图
+
+目前Go支持mongoDB最好的驱动就是[mgo](http://labix.org/mgo)，这个驱动目前最有可能成为官方的pkg。
+
+下面我将演示如何通过Go来操作mongoDB：
+
+	package main
+
+	import (
+		"fmt"
+		"labix.org/v2/mgo"
+		"labix.org/v2/mgo/bson"
+	)
+
+	type Person struct {
+		Name string
+		Phone string
+	}
+
+	func main() {
+		session, err := mgo.Dial("server1.example.com,server2.example.com")
+		if err != nil {
+			panic(err)
+		}
+		defer session.Close()
+
+		session.SetMode(mgo.Monotonic, true)
+
+		c := session.DB("test").C("people")
+		err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
+			&Person{"Cla", "+55 53 8402 8510"})
+		if err != nil {
+			panic(err)
+		}
+
+		result := Person{}
+		err = c.Find(bson.M{"name": "Ale"}).One(&result)
+		if err != nil {
+			panic(err)
+		}
+
+		fmt.Println("Phone:", result.Phone)
+	}
+
+我们可以看出来mgo的操作方式和beedb的操作方式几乎类似，都是基于strcut的操作方式，这个就是Go Style。
+
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [使用beedb库进行ORM开发](<05.5.md>)
+   * 下一节: [小结](<05.7.md>)

05.7.md → ebook/05.7.md

-# 5.7 小结
-这一章我们讲解了Go如何设计database/sql接口，然后介绍了各种第三方关系型数据库驱动的使用。接着介绍了beedb，一种基于关系型数据库的ORM库，如何对数据库进行简单的操作。最后介绍了NOSQL的一些知识，目前Go对于NOSQL支持还是不错，因为Go作为21世纪的C语言，那么对于21世纪的数据库也是支持的相当好。
-
-通过这一章的学习，我们学会了如何操作各种数据库，那么就解决了我们数据存储的问题，这是Web里面最重要的一部分，所以希望大家能够深入的去了解database/sql的设计思想。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [NOSQL数据库操作](<05.6.md>)
-   * 下一章: [session和数据存储](<06.0.md>)
+# 5.7 小结
+这一章我们讲解了Go如何设计database/sql接口，然后介绍了各种第三方关系型数据库驱动的使用。接着介绍了beedb，一种基于关系型数据库的ORM库，如何对数据库进行简单的操作。最后介绍了NOSQL的一些知识，目前Go对于NOSQL支持还是不错，因为Go作为21世纪的C语言，那么对于21世纪的数据库也是支持的相当好。
+
+通过这一章的学习，我们学会了如何操作各种数据库，那么就解决了我们数据存储的问题，这是Web里面最重要的一部分，所以希望大家能够深入的去了解database/sql的设计思想。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [NOSQL数据库操作](<05.6.md>)
+   * 下一章: [session和数据存储](<06.0.md>)

06.0.md → ebook/06.0.md

-# 6 session和数据存储
-Web开发中一个很重要的议题就是如何做好用户的整个浏览过程的控制，因为HTTP协议是无状态的，所以用户的每一次请求都是无状态的，我们不知道在整个Web操作过程中哪些连接与该用户有关，我们应该如何来解决这个问题呢？Web里面经典的解决方案是cookie和session，cookie机制是一种客户端机制，把用户数据保存在客户端，而session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构来保存信息，每一个网站访客都会被分配给一个唯一的标志符,即sessionID,它的存放形式无非两种:要么经过url传递,要么保存在客户端的cookies里.当然,你也可以将Session保存到数据库里,这样会更安全,但效率方面会有所下降。
-
-6.1小节里面讲介绍session机制和cookie机制的关系和区别，6.2讲解Go语言如何来实现session，里面讲实现一个简易的session管理器，6.3小节讲解如何防止session被劫持的情况，如何有效的保护session。我们知道session其实可以存储在任何地方，6.3小节里面实现的session是存储在内存中的，但是如果我们的应用进一步扩展了，要实现应用的session共享，那么我们可以把session存储在数据库中(memcache或者redis)，6.4小节将详细的讲解如何实现这些功能。
-
-## 目录
-   ![](images/navi6.png?raw=true)
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第五章总结](<05.7.md>)
-   * 下一节: [session和cookie](<06.1.md>)
+# 6 session和数据存储
+Web开发中一个很重要的议题就是如何做好用户的整个浏览过程的控制，因为HTTP协议是无状态的，所以用户的每一次请求都是无状态的，我们不知道在整个Web操作过程中哪些连接与该用户有关，我们应该如何来解决这个问题呢？Web里面经典的解决方案是cookie和session，cookie机制是一种客户端机制，把用户数据保存在客户端，而session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构来保存信息，每一个网站访客都会被分配给一个唯一的标志符,即sessionID,它的存放形式无非两种:要么经过url传递,要么保存在客户端的cookies里.当然,你也可以将Session保存到数据库里,这样会更安全,但效率方面会有所下降。
+
+6.1小节里面讲介绍session机制和cookie机制的关系和区别，6.2讲解Go语言如何来实现session，里面讲实现一个简易的session管理器，6.3小节讲解如何防止session被劫持的情况，如何有效的保护session。我们知道session其实可以存储在任何地方，6.3小节里面实现的session是存储在内存中的，但是如果我们的应用进一步扩展了，要实现应用的session共享，那么我们可以把session存储在数据库中(memcache或者redis)，6.4小节将详细的讲解如何实现这些功能。
+
+## 目录
+   ![](images/navi6.png?raw=true)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第五章总结](<05.7.md>)
+   * 下一节: [session和cookie](<06.1.md>)

06.1.md → ebook/06.1.md

-# 6.1 session和cookie
-session和cookie是网站浏览中较为常见的两个概念，也是比较难以辨析的两个概念，但它们在浏览需要认证的服务页面以及页面统计中却相当关键。我们先来了解一下session和cookie怎么来的？考虑这样一个问题：
-
-如何抓取一个访问受限的网页？如新浪微博好友的主页，个人微博页面等。
-
-显然，通过浏览器，我们可以手动输入用户名和密码来访问页面，而所谓的“抓取”，其实就是使用程序来模拟完成同样的工作，因此我们需要了解“登陆”过程中到底发生了什么。
-
-当用户来到微博登陆页面，输入用户名和密码之后点击“登录”后浏览器将认证信息POST给远端的服务器，服务器执行验证逻辑，如果验证通过，则浏览器会跳转到登录用户的微博首页，在登录成功后，服务器如何验证我们对其他受限制页面的访问呢？因为HTTP协议是无状态的，所以很显然服务器不可能知道我们已经在上一次的HTTP请求中通过了验证。当然，最简单的解决方案就是所有的请求里面都带上用户名和密码，这样虽然可行，但大大加重了服务器的负担（对于每个request都需要到数据库验证），也大大降低了用户体验(每个页面都需要重新输入用户名密码，每个页面都带有登录表单)。既然直接在请求中带上用户名与密码不可行，那么就只有在服务器或客户端保存一些类似的可以代表身份的信息了，所以就有了cookie与session。
-
-cookie，简而言之就是在本地计算机保存一些用户操作的历史信息（当然包括登录信息），并在用户再次访问该站点时浏览器通过HTTP协议将本地cookie内容发送给服务器，从而完成验证，或继续上一步操作。
-
-![](images/6.1.cookie2.png?raw=true)
-
-图6.1 cookie的原理图
-
-session，简而言之就是在服务器上保存用户操作的历史信息。服务器使用session id来标识session，session id由服务器负责产生，保证随机性与唯一性，相当于一个随机密钥，避免在握手或传输中暴露用户真实密码。但该方式下，仍然需要将发送请求的客户端与session进行对应，所以可以借助cookie机制来获取客户端的标识（即session id），也可以通过GET方式将id提交给服务器。
-
-![](images/6.1.session.png?raw=true)
-
-图6.2 session的原理图
-
-## cookie
-Cookie是由浏览器维持的，存储在客户端的一小段文本信息，伴随着用户请求和页面在Web服务器和浏览器之间传递。用户每次访问站点时，Web应用程序都可以读取cookie包含的信息。浏览器设置里面有cookie隐私数据选项，打开它，可以看到很多已访问网站的cookies，如下图所示：
-
-![](images/6.1.cookie.png?raw=true)
-
-图6.3 浏览器端保存的cookie信息
-
-cookie是有时间限制的，根据生命期不同分成两种：会话cookie和持久cookie；
-
-如果不设置过期时间，则表示这个cookie生命周期为从创建到浏览器关闭止，只要关闭浏览器窗口，cookie就消失了。这种生命期为浏览会话期的cookie被称为会话cookie。会话cookie一般不保存在硬盘上而是保存在内存里。
-
-如果设置了过期时间(setMaxAge(60*60*24))，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie依然有效直到超过设定的过期时间。存储在硬盘上的cookie可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存的cookie，不同的浏览器有不同的处理方式。
-　　
-
-### Go设置cookie
-Go语言中通过net/http包中的SetCookie来设置：
-
-	http.SetCookie(w ResponseWriter, cookie *Cookie)
-
-w表示需要写入的response，cookie是一个struct，让我们来看一下cookie对象是怎么样的
-
-	type Cookie struct {
-		Name       string
-		Value      string
-		Path       string
-		Domain     string
-		Expires    time.Time
-		RawExpires string
-
-	// MaxAge=0 means no 'Max-Age' attribute specified.
-	// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
-	// MaxAge>0 means Max-Age attribute present and given in seconds
-		MaxAge   int
-		Secure   bool
-		HttpOnly bool
-		Raw      string
-		Unparsed []string // Raw text of unparsed attribute-value pairs
-	}
-
-我们来看一个例子，如何设置cookie
-
-	expiration := *time.LocalTime()
-	expiration.Year += 1
-	cookie := http.Cookie{Name: "username", Value: "astaxie", Expires: expiration}
-	http.SetCookie(w, &cookie)
-
-　　
-### Go读取cookie
-上面的例子演示了如何设置cookie数据，我们这里来演示一下如何读取cookie
-
-	cookie, _ := r.Cookie("username")
-	fmt.Fprint(w, cookie)
-
-还有另外一种读取方式
-
-	for _, cookie := range r.Cookies() {
-		fmt.Fprint(w, cookie.Name)
-	}
-
-可以看到通过request获取cookie非常方便。
-
-## session
-
-session，中文经常翻译为会话，其本来的含义是指有始有终的一系列动作/消息，比如打电话是从拿起电话拨号到挂断电话这中间的一系列过程可以称之为一个session。然而当session一词与网络协议相关联时，它又往往隐含了“面向连接”和/或“保持状态”这样两个含义。
-
-session在Web开发环境下的语义又有了新的扩展，它的含义是指一类用来在客户端与服务器端之间保持状态的解决方案。有时候Session也用来指这种解决方案的存储结构。
-
-session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构(也可能就是使用散列表)来保存息。
-
-但程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否包含了一个session标识－称为session id，如果已经包含一个session id则说明以前已经为此客户创建过session，服务器就按照session id把这个session检索出来使用(如果检索不到，可能会新建一个，这种情况可能出现在服务端已经删除了该用户对应的session对象，但用户人为地在请求的URL后面附加上一个JSESSION的参数)。如果客户请求不包含session id，则为此客户创建一个session并且同时生成一个与此session相关联的session id，这个session id将在本次响应中返回给客户端保存。
-
-session机制本身并不复杂，然而其实现和配置上的灵活性却使得具体情况复杂多变。这也要求我们不能把仅仅某一次的经验或者某一个浏览器，服务器的经验当作普遍适用的。
-
-## 小结
-
-如上文所述，session和cookie的目的相同，都是为了克服http协议无状态的缺陷，但完成的方法不同。session通过cookie，在客户端保存session id，而将用户的其他会话消息保存在服务端的session对象中，与此相对的，cookie需要将所有信息都保存在客户端。因此cookie存在着一定的安全隐患，例如本地cookie中保存的用户名密码被破译，或cookie被其他网站收集（例如：1. appA主动设置域B cookie，让域B cookie获取；2. XSS，在appA上通过javascript获取document.cookie，并传递给自己的appB）。
-
-
-通过上面的一些简单介绍我们了解了cookie和session的一些基础知识，知道他们之间的联系和区别，做web开发之前，有必要将一些必要知识了解清楚，才不会在用到时捉襟见肘，或是在调bug时候如无头苍蝇乱转。接下来的几小节我们将详细介绍session相关的知识。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [session和数据存储](<06.0.md>)
-   * 下一节: [Go如何使用session](<06.2.md>)
+# 6.1 session和cookie
+session和cookie是网站浏览中较为常见的两个概念，也是比较难以辨析的两个概念，但它们在浏览需要认证的服务页面以及页面统计中却相当关键。我们先来了解一下session和cookie怎么来的？考虑这样一个问题：
+
+如何抓取一个访问受限的网页？如新浪微博好友的主页，个人微博页面等。
+
+显然，通过浏览器，我们可以手动输入用户名和密码来访问页面，而所谓的“抓取”，其实就是使用程序来模拟完成同样的工作，因此我们需要了解“登陆”过程中到底发生了什么。
+
+当用户来到微博登陆页面，输入用户名和密码之后点击“登录”后浏览器将认证信息POST给远端的服务器，服务器执行验证逻辑，如果验证通过，则浏览器会跳转到登录用户的微博首页，在登录成功后，服务器如何验证我们对其他受限制页面的访问呢？因为HTTP协议是无状态的，所以很显然服务器不可能知道我们已经在上一次的HTTP请求中通过了验证。当然，最简单的解决方案就是所有的请求里面都带上用户名和密码，这样虽然可行，但大大加重了服务器的负担（对于每个request都需要到数据库验证），也大大降低了用户体验(每个页面都需要重新输入用户名密码，每个页面都带有登录表单)。既然直接在请求中带上用户名与密码不可行，那么就只有在服务器或客户端保存一些类似的可以代表身份的信息了，所以就有了cookie与session。
+
+cookie，简而言之就是在本地计算机保存一些用户操作的历史信息（当然包括登录信息），并在用户再次访问该站点时浏览器通过HTTP协议将本地cookie内容发送给服务器，从而完成验证，或继续上一步操作。
+
+![](images/6.1.cookie2.png?raw=true)
+
+图6.1 cookie的原理图
+
+session，简而言之就是在服务器上保存用户操作的历史信息。服务器使用session id来标识session，session id由服务器负责产生，保证随机性与唯一性，相当于一个随机密钥，避免在握手或传输中暴露用户真实密码。但该方式下，仍然需要将发送请求的客户端与session进行对应，所以可以借助cookie机制来获取客户端的标识（即session id），也可以通过GET方式将id提交给服务器。
+
+![](images/6.1.session.png?raw=true)
+
+图6.2 session的原理图
+
+## cookie
+Cookie是由浏览器维持的，存储在客户端的一小段文本信息，伴随着用户请求和页面在Web服务器和浏览器之间传递。用户每次访问站点时，Web应用程序都可以读取cookie包含的信息。浏览器设置里面有cookie隐私数据选项，打开它，可以看到很多已访问网站的cookies，如下图所示：
+
+![](images/6.1.cookie.png?raw=true)
+
+图6.3 浏览器端保存的cookie信息
+
+cookie是有时间限制的，根据生命期不同分成两种：会话cookie和持久cookie；
+
+如果不设置过期时间，则表示这个cookie生命周期为从创建到浏览器关闭止，只要关闭浏览器窗口，cookie就消失了。这种生命期为浏览会话期的cookie被称为会话cookie。会话cookie一般不保存在硬盘上而是保存在内存里。
+
+如果设置了过期时间(setMaxAge(60*60*24))，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie依然有效直到超过设定的过期时间。存储在硬盘上的cookie可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存的cookie，不同的浏览器有不同的处理方式。
+　　
+
+### Go设置cookie
+Go语言中通过net/http包中的SetCookie来设置：
+
+	http.SetCookie(w ResponseWriter, cookie *Cookie)
+
+w表示需要写入的response，cookie是一个struct，让我们来看一下cookie对象是怎么样的
+
+	type Cookie struct {
+		Name       string
+		Value      string
+		Path       string
+		Domain     string
+		Expires    time.Time
+		RawExpires string
+
+	// MaxAge=0 means no 'Max-Age' attribute specified.
+	// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
+	// MaxAge>0 means Max-Age attribute present and given in seconds
+		MaxAge   int
+		Secure   bool
+		HttpOnly bool
+		Raw      string
+		Unparsed []string // Raw text of unparsed attribute-value pairs
+	}
+
+我们来看一个例子，如何设置cookie
+
+	expiration := *time.LocalTime()
+	expiration.Year += 1
+	cookie := http.Cookie{Name: "username", Value: "astaxie", Expires: expiration}
+	http.SetCookie(w, &cookie)
+
+　　
+### Go读取cookie
+上面的例子演示了如何设置cookie数据，我们这里来演示一下如何读取cookie
+
+	cookie, _ := r.Cookie("username")
+	fmt.Fprint(w, cookie)
+
+还有另外一种读取方式
+
+	for _, cookie := range r.Cookies() {
+		fmt.Fprint(w, cookie.Name)
+	}
+
+可以看到通过request获取cookie非常方便。
+
+## session
+
+session，中文经常翻译为会话，其本来的含义是指有始有终的一系列动作/消息，比如打电话是从拿起电话拨号到挂断电话这中间的一系列过程可以称之为一个session。然而当session一词与网络协议相关联时，它又往往隐含了“面向连接”和/或“保持状态”这样两个含义。
+
+session在Web开发环境下的语义又有了新的扩展，它的含义是指一类用来在客户端与服务器端之间保持状态的解决方案。有时候Session也用来指这种解决方案的存储结构。
+
+session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构(也可能就是使用散列表)来保存息。
+
+但程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否包含了一个session标识－称为session id，如果已经包含一个session id则说明以前已经为此客户创建过session，服务器就按照session id把这个session检索出来使用(如果检索不到，可能会新建一个，这种情况可能出现在服务端已经删除了该用户对应的session对象，但用户人为地在请求的URL后面附加上一个JSESSION的参数)。如果客户请求不包含session id，则为此客户创建一个session并且同时生成一个与此session相关联的session id，这个session id将在本次响应中返回给客户端保存。
+
+session机制本身并不复杂，然而其实现和配置上的灵活性却使得具体情况复杂多变。这也要求我们不能把仅仅某一次的经验或者某一个浏览器，服务器的经验当作普遍适用的。
+
+## 小结
+
+如上文所述，session和cookie的目的相同，都是为了克服http协议无状态的缺陷，但完成的方法不同。session通过cookie，在客户端保存session id，而将用户的其他会话消息保存在服务端的session对象中，与此相对的，cookie需要将所有信息都保存在客户端。因此cookie存在着一定的安全隐患，例如本地cookie中保存的用户名密码被破译，或cookie被其他网站收集（例如：1. appA主动设置域B cookie，让域B cookie获取；2. XSS，在appA上通过javascript获取document.cookie，并传递给自己的appB）。
+
+
+通过上面的一些简单介绍我们了解了cookie和session的一些基础知识，知道他们之间的联系和区别，做web开发之前，有必要将一些必要知识了解清楚，才不会在用到时捉襟见肘，或是在调bug时候如无头苍蝇乱转。接下来的几小节我们将详细介绍session相关的知识。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [session和数据存储](<06.0.md>)
+   * 下一节: [Go如何使用session](<06.2.md>)

06.4.md → ebook/06.4.md

-# 6.4 预防session劫持
-session劫持是一种广泛存在的比较严重的安全威胁，在session技术中，客户端和服务端通过session的标识符来维护会话， 但这个标识符很容易就能被嗅探到，从而被其他人利用.它是中间人攻击的一种类型。
-
-本节将通过一个实例来演示会话劫持，希望通过这个实例，能让读者更好地理解session的本质。
-## session劫持过程
-我们写了如下的代码来展示一个count计数器：
-
-	func count(w http.ResponseWriter, r *http.Request) {
-		sess := globalSessions.SessionStart(w, r)
-		ct := sess.Get("countnum")
-		if ct == nil {
-			sess.Set("countnum", 1)
-		} else {
-			sess.Set("countnum", (ct.(int) + 1))
-		}
-		t, _ := template.ParseFiles("count.gtpl")
-		w.Header().Set("Content-Type", "text/html")
-		t.Execute(w, sess.Get("countnum"))
-	}
-
-
-count.gtpl的代码如下所示：
-
-	Hi. Now count:{{.}}
-
-然后我们在浏览器里面刷新可以看到如下内容：
-
-![](images/6.4.hijack.png?raw=true)
-
-图6.4 浏览器端显示count数
-
-随着刷新，数字将不断增长，当数字显示为6的时候，打开浏览器(以chrome为例）的cookie管理器，可以看到类似如下的信息：
-
-
-![](images/6.4.cookie.png?raw=true)
-
-图6.5 获取浏览器端保存的cookie
-
-下面这个步骤最为关键: 打开另一个浏览器(这里我打开了firefox浏览器),复制chrome地址栏里的地址到新打开的浏览器的地址栏中。然后打开firefox的cookie模拟插件，新建一个cookie，把按上图中cookie内容原样在firefox中重建一份:
-
-![](images/6.4.setcookie.png?raw=true)
-
-图6.6 模拟cookie
-
-回车后，你将看到如下内容：
-
-![](images/6.4.hijacksuccess.png?raw=true)
-
-图6.7 劫持session成功
-
-可以看到虽然换了浏览器，但是我们却获得了sessionID，然后模拟了cookie存储的过程。这个例子是在同一台计算机上做的，不过即使换用两台来做，其结果仍然一样。此时如果交替点击两个浏览器里的链接你会发现它们其实操纵的是同一个计数器。不必惊讶，此处firefox盗用了chrome和goserver之间的维持会话的钥匙，即gosessionid，这是一种类型的“会话劫持”。在goserver看来，它从http请求中得到了一个gosessionid，由于HTTP协议的无状态性，它无法得知这个gosessionid是从chrome那里“劫持”来的，它依然会去查找对应的session，并执行相关计算。与此同时 chrome也无法得知自己保持的会话已经被“劫持”。
-## session劫持防范
-### cookieonly和token
-通过上面session劫持的简单演示可以了解到session一旦被其他人劫持，就非常危险，劫持者可以假装成被劫持者进行很多非法操作。那么如何有效的防止session劫持呢？
-
-其中一个解决方案就是sessionID的值只允许cookie设置，而不是通过URL重置方式设置，同时设置cookie的httponly为true,这个属性是设置是否可通过客户端脚本访问这个设置的cookie，第一这个可以防止这个cookie被XSS读取从而引起session劫持，第二cookie设置不会像URL重置方式那么容易获取sessionID。
-
-第二步就是在每个请求里面加上token，实现类似前面章节里面讲的防止form重复递交类似的功能，我们在每个请求里面加上一个隐藏的token，然后每次验证这个token，从而保证用户的请求都是唯一性。
-
-	h := md5.New()
-	salt:="astaxie%^7&8888"
-	io.WriteString(h,salt+time.Now().String())
-	token:=fmt.Sprintf("%x",h.Sum(nil))
-	if r.Form["token"]!=token{
-		//提示登录
-	}
-	sess.Set("token",token)
-
-
-### 间隔生成新的SID
-还有一个解决方案就是，我们给session额外设置一个创建时间的值，一旦过了一定的时间，我们销毁这个sessionID，重新生成新的session，这样可以一定程度上防止session劫持的问题。
-
-	createtime := sess.Get("createtime")
-	if createtime == nil {
-		sess.Set("createtime", time.Now().Unix())
-	} else if (createtime.(int64) + 60) < (time.Now().Unix()) {
-		globalSessions.SessionDestroy(w, r)
-		sess = globalSessions.SessionStart(w, r)
-	}
-
-session启动后，我们设置了一个值，用于记录生成sessionID的时间。通过判断每次请求是否过期(这里设置了60秒)定期生成新的ID，这样使得攻击者获取有效sessionID的机会大大降低。
-
-上面两个手段的组合可以在实践中消除session劫持的风险，一方面，	由于sessionID频繁改变，使攻击者难有机会获取有效的sessionID；另一方面，因为sessionID只能在cookie中传递，然后设置了httponly，所以基于URL攻击的可能性为零，同时被XSS获取sessionID也不可能。最后，由于我们还设置了MaxAge=0，这样就相当于session cookie不会留在浏览器的历史记录里面。
-
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [session存储](<06.3.md>)
-   * 下一节: [小结](<06.5.md>)
+# 6.4 预防session劫持
+session劫持是一种广泛存在的比较严重的安全威胁，在session技术中，客户端和服务端通过session的标识符来维护会话， 但这个标识符很容易就能被嗅探到，从而被其他人利用.它是中间人攻击的一种类型。
+
+本节将通过一个实例来演示会话劫持，希望通过这个实例，能让读者更好地理解session的本质。
+## session劫持过程
+我们写了如下的代码来展示一个count计数器：
+
+	func count(w http.ResponseWriter, r *http.Request) {
+		sess := globalSessions.SessionStart(w, r)
+		ct := sess.Get("countnum")
+		if ct == nil {
+			sess.Set("countnum", 1)
+		} else {
+			sess.Set("countnum", (ct.(int) + 1))
+		}
+		t, _ := template.ParseFiles("count.gtpl")
+		w.Header().Set("Content-Type", "text/html")
+		t.Execute(w, sess.Get("countnum"))
+	}
+
+
+count.gtpl的代码如下所示：
+
+	Hi. Now count:{{.}}
+
+然后我们在浏览器里面刷新可以看到如下内容：
+
+![](images/6.4.hijack.png?raw=true)
+
+图6.4 浏览器端显示count数
+
+随着刷新，数字将不断增长，当数字显示为6的时候，打开浏览器(以chrome为例）的cookie管理器，可以看到类似如下的信息：
+
+
+![](images/6.4.cookie.png?raw=true)
+
+图6.5 获取浏览器端保存的cookie
+
+下面这个步骤最为关键: 打开另一个浏览器(这里我打开了firefox浏览器),复制chrome地址栏里的地址到新打开的浏览器的地址栏中。然后打开firefox的cookie模拟插件，新建一个cookie，把按上图中cookie内容原样在firefox中重建一份:
+
+![](images/6.4.setcookie.png?raw=true)
+
+图6.6 模拟cookie
+
+回车后，你将看到如下内容：
+
+![](images/6.4.hijacksuccess.png?raw=true)
+
+图6.7 劫持session成功
+
+可以看到虽然换了浏览器，但是我们却获得了sessionID，然后模拟了cookie存储的过程。这个例子是在同一台计算机上做的，不过即使换用两台来做，其结果仍然一样。此时如果交替点击两个浏览器里的链接你会发现它们其实操纵的是同一个计数器。不必惊讶，此处firefox盗用了chrome和goserver之间的维持会话的钥匙，即gosessionid，这是一种类型的“会话劫持”。在goserver看来，它从http请求中得到了一个gosessionid，由于HTTP协议的无状态性，它无法得知这个gosessionid是从chrome那里“劫持”来的，它依然会去查找对应的session，并执行相关计算。与此同时 chrome也无法得知自己保持的会话已经被“劫持”。
+## session劫持防范
+### cookieonly和token
+通过上面session劫持的简单演示可以了解到session一旦被其他人劫持，就非常危险，劫持者可以假装成被劫持者进行很多非法操作。那么如何有效的防止session劫持呢？
+
+其中一个解决方案就是sessionID的值只允许cookie设置，而不是通过URL重置方式设置，同时设置cookie的httponly为true,这个属性是设置是否可通过客户端脚本访问这个设置的cookie，第一这个可以防止这个cookie被XSS读取从而引起session劫持，第二cookie设置不会像URL重置方式那么容易获取sessionID。
+
+第二步就是在每个请求里面加上token，实现类似前面章节里面讲的防止form重复递交类似的功能，我们在每个请求里面加上一个隐藏的token，然后每次验证这个token，从而保证用户的请求都是唯一性。
+
+	h := md5.New()
+	salt:="astaxie%^7&8888"
+	io.WriteString(h,salt+time.Now().String())
+	token:=fmt.Sprintf("%x",h.Sum(nil))
+	if r.Form["token"]!=token{
+		//提示登录
+	}
+	sess.Set("token",token)
+
+
+### 间隔生成新的SID
+还有一个解决方案就是，我们给session额外设置一个创建时间的值，一旦过了一定的时间，我们销毁这个sessionID，重新生成新的session，这样可以一定程度上防止session劫持的问题。
+
+	createtime := sess.Get("createtime")
+	if createtime == nil {
+		sess.Set("createtime", time.Now().Unix())
+	} else if (createtime.(int64) + 60) < (time.Now().Unix()) {
+		globalSessions.SessionDestroy(w, r)
+		sess = globalSessions.SessionStart(w, r)
+	}
+
+session启动后，我们设置了一个值，用于记录生成sessionID的时间。通过判断每次请求是否过期(这里设置了60秒)定期生成新的ID，这样使得攻击者获取有效sessionID的机会大大降低。
+
+上面两个手段的组合可以在实践中消除session劫持的风险，一方面，	由于sessionID频繁改变，使攻击者难有机会获取有效的sessionID；另一方面，因为sessionID只能在cookie中传递，然后设置了httponly，所以基于URL攻击的可能性为零，同时被XSS获取sessionID也不可能。最后，由于我们还设置了MaxAge=0，这样就相当于session cookie不会留在浏览器的历史记录里面。
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [session存储](<06.3.md>)
+   * 下一节: [小结](<06.5.md>)

06.5.md → ebook/06.5.md

-# 6.5 小结
-这章我们学习了什么是session，什么是cookie，以及他们两者之间的关系。但是目前Go官方标准包里面不支持session，所以我们设计了一个session管理器，实现了session从创建到销毁的整个过程。然后定义了Provider的接口，使得可以支持各种后端的session存储，然后我们在第三小节里面介绍了如何使用内存存储来实现session的管理。第四小节我们讲解了session劫持的过程，以及我们如何有效的来防止session劫持。通过这一章的讲解，希望能够让读者了解整个sesison的执行原理以及如何实现，而且是如何更加安全的使用session。
-## links
-   * [目录](<preface.md>)
-   * 上一节: [session存储](<06.4.md>)
-   * 下一章: [文本处理](<07.0.md>)
+# 6.5 小结
+这章我们学习了什么是session，什么是cookie，以及他们两者之间的关系。但是目前Go官方标准包里面不支持session，所以我们设计了一个session管理器，实现了session从创建到销毁的整个过程。然后定义了Provider的接口，使得可以支持各种后端的session存储，然后我们在第三小节里面介绍了如何使用内存存储来实现session的管理。第四小节我们讲解了session劫持的过程，以及我们如何有效的来防止session劫持。通过这一章的讲解，希望能够让读者了解整个sesison的执行原理以及如何实现，而且是如何更加安全的使用session。
+## links
+   * [目录](<preface.md>)
+   * 上一节: [session存储](<06.4.md>)
+   * 下一章: [文本处理](<07.0.md>)

08.5.md → ebook/08.5.md

-# 8.5 小结
-这一章我们介绍了目前流行的几种主要的网络应用开发方式，第一小节介绍了网络编程中的基础:Socket编程，因为现在网络正在朝云的方向快速进化，作为这一技术演进的基石的的socket知识，作为开发者的你，是必须要掌握的。第二小节介绍了正愈发流行的HTML5中一个重要的特性WebSocket，通过它,服务器可以实现主动的push消息，以简化以前ajax轮询的模式。第三小节介绍了REST编写模式，这种模式特别适合来开发网络应用API，目前移动应用的快速发展，我觉得将来会是一个潮流。第四小节介绍了Go实现的RPC相关知识，对于上面四种开发方式，Go都已经提供了良好的支持，net包及其子包,是所有涉及到网络编程的工具的所在地。如果你想更加深入的了解相关实现细节，可以尝试阅读这个包下面的源码。
-## links
-   * [目录](<preface.md>)
-   * 上一节: [RPC](<08.4.md>)
-   * 下一章: [安全与加密](<09.0.md>)
+# 8.5 小结
+这一章我们介绍了目前流行的几种主要的网络应用开发方式，第一小节介绍了网络编程中的基础:Socket编程，因为现在网络正在朝云的方向快速进化，作为这一技术演进的基石的的socket知识，作为开发者的你，是必须要掌握的。第二小节介绍了正愈发流行的HTML5中一个重要的特性WebSocket，通过它,服务器可以实现主动的push消息，以简化以前ajax轮询的模式。第三小节介绍了REST编写模式，这种模式特别适合来开发网络应用API，目前移动应用的快速发展，我觉得将来会是一个潮流。第四小节介绍了Go实现的RPC相关知识，对于上面四种开发方式，Go都已经提供了良好的支持，net包及其子包,是所有涉及到网络编程的工具的所在地。如果你想更加深入的了解相关实现细节，可以尝试阅读这个包下面的源码。
+## links
+   * [目录](<preface.md>)
+   * 上一节: [RPC](<08.4.md>)
+   * 下一章: [安全与加密](<09.0.md>)

10.4.md → ebook/10.4.md

-# 10.4 小结
-通过这一章的介绍，读者应该对如何操作i18n有了深入的了解，我也根据这一章介绍的内容实现了一个开源的解决方案go-i18n：https://github.com/astaxie/go-i18n  通过这个开源库我们可以很方便的实现多语言版本的Web应用，使得我们的应用能够轻松的实现国际化。如果你发现这个开源库中的错误或者那些缺失的地方，请一起参与到这个开源项目中来，让我们的这个库争取成为Go的标准库。
-## links
-  * [目录](<preface.md>)
-  * 上一节: [国际化站点](<10.3.md>)
-  * 下一节: [错误处理，故障排除和测试](<11.0.md>)
+# 10.4 小结
+通过这一章的介绍，读者应该对如何操作i18n有了深入的了解，我也根据这一章介绍的内容实现了一个开源的解决方案go-i18n：https://github.com/astaxie/go-i18n  通过这个开源库我们可以很方便的实现多语言版本的Web应用，使得我们的应用能够轻松的实现国际化。如果你发现这个开源库中的错误或者那些缺失的地方，请一起参与到这个开源项目中来，让我们的这个库争取成为Go的标准库。
+## links
+  * [目录](<preface.md>)
+  * 上一节: [国际化站点](<10.3.md>)
+  * 下一节: [错误处理，故障排除和测试](<11.0.md>)