diff --git a/.gitignore b/.gitignore deleted file mode 100644 index d87c27bd..00000000 --- a/.gitignore +++ /dev/null @@ -1,9 +0,0 @@ -# Compiled files. -*.exe -*.html -*.ps -*.eps -*.pdf -*.aux -*.log -.gitignore \ No newline at end of file diff --git a/1.1.md b/1.1.md index fba93b98..6495ae10 100644 --- a/1.1.md +++ b/1.1.md @@ -1,134 +1,139 @@ -# 1.1 Go 安装 - -## Go的三种安装方式 -Go有多种安装方式，你可以选择自己喜欢的。这里我们介绍三种最常见的安装方式： - -- 从编译源码安装：这是一种标准的软件安装方式。对于经常使用Unix类系统的用户，尤其对于开发者来说，从源码安装是最方便而熟悉的。 -- 安装Go标准包：Go提供了方便的安装包，支持Windows、Linux、Mac等系统。这种方式适合初学者，可根据自己的系统位数下载好相应的安装包，一路next就可以轻松安装了。 -- 用软件包管理工具：目前有很多方便的第三方软件包工具，例如Ubuntu的apt-get、Mac的homebrew等。这种安装方式适合那些熟悉相应系统的用户。 - -最后，如果你想在同一个系统中安装多个版本的Go，你可以参考第三方工具[GVM](https://github.com/moovweb/gvm)，这是目前在这方面做得最好的工具，除非你知道怎么处理。 - -### Go源码安装 -在Go的源代码中，有些部分是用Plan 9 C和AT&T汇编写的，因此假如你要想从源码安装，就必须安装C的编译工具。 - -在Mac系统中，只要你安装了Xcode，就已经包含了相应的编译工具。 - -在类Unix系统中，需要安装gcc等工具。例如Ubuntu系统可通过在终端中执行`sudo apt-get install gcc libc6-dev`来安装编译工具。 - -在Windows系统中，你需要安装MinGW，然后通过MinGW安装gcc，并设置相应的环境变量。 - -Go使用[Mercurial][hg]进行版本管理，首先你必须安装了Mercurial，然后才能下载。假设你已经安装好Mercurial，执行如下代码： - -假设已经位于Go的安装目录 `$GO_INSTALL_DIR`下 - - hg clone -u release https://code.google.com/p/go - cd go/src - ./all.bash - -运行all.bash后出现"ALL TESTS PASSED"字样时才算安装成功。 - -上面是Unix风格的命令，Windows下的安装方式类似，只不过是运行all.bat，调用的编译器是MinGW的gcc。 - -然后设置几个环境变量， - - export GOROOT=$HOME/go - export GOBIN=$GOROOT/bin - export PATH=$PATH:$GOBIN - -看到如下图片即说明你已经安装成功 - -![](images/1.1.mac.png?raw=true) - -如果出现Go的Usage信息，那么说明Go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了Go的安装目录。 - - -## Go标准包安装 - -### 如何判断自己的操作系统是32位还是64位？ - -我们接下来的Go安装需要判断操作系统的位数，所以这小节我们先确定自己的系统类型。 - -Windows系统用户请按Win+R运行cmd，输入`systeminfo`后回车，稍等片刻，会出现一些系统信息。在“系统类型”一行中，若显示“x64-based PC”，即为64位系统；若显示“X86-based PC”，则为32位系统。 - -Mac系统用户建议直接使用64位的，因为Go所支持的Mac OS X版本已经不支持纯32位处理器了。 - -Linux系统用户可通过在Terminal中执行命令`uname -a`来查看系统信息： - -64位系统显示 - - <一段描述> x86_64 x86_64 x86_64 GNU/Linux - //有些机器显示如下，例如ubuntu10.04 - x86_64 GNU/Linux - -32位系统显示 - - <一段描述> i686 i686 i386 GNU/Linux - -### Mac 安装 - -访问[下载地址][downlink]，32位系统下载go1.0.3.darwin-386.pkg，64位系统下载go1.0.3.darwin-amd64.pkg，双击下载文件，一路默认安装点击下一步，这个时候go已经安装到你的系统中，默认已经在PATH中增加了相应的`~/go/bin`,这个时候打开终端，输入`go` - -看到如下图片说明已经安装成功 - -![](images/1.1.mac.png?raw=true) - -如果出现go的Usage信息，那么说明go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了go的安装目录。 - -### Linux 安装 - -访问[下载地址][downlink]，32位系统下载go1.0.3.linux-386.tar.gz，64位系统下载go1.0.3.linux-amd64.tar.gz， - -假定你想要安装Go的目录为 `$GO_INSTALL_DIR`，后面替换为相应的目录路径。 - -解压缩`tar.gz`包到安装目录下：`tar zxvf go1.0.3.linux-amd64.tar.gz -C $GO_INSTALL_DIR`。 - -设置PATH，`export PATH=$PATH:$GO_INSTALL_DIR/go/bin` - -然后执行`go` - -看到类似上面mac安装成功的图片说明已经安装成功 - -如果出现go的Usage信息，那么说明go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了go的安装目录。 - -### Windows 安装 - -访问[下载地址][downlink]，32位系统下载go1.0.3.windows-386.msi，64位系统下载go1.0.3.windows-amd64.msi。双击打开下载的文件，一路按照默认点击下一步，这个时候go已经安装到你的系统中，默认安装之后已经在你的系统环境变量中加入了`c:/go/bin`，这个时候打开cmd，输入`go` - -看到类似上面mac安装成功的图片说明已经安装成功 - -如果出现Go的Usage信息，那么说明Go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了Go的安装目录。 - -## 第三方工具安装 -### GVM -gvm是第三方开发的Go多版本管理工具，类似ruby里面的rvm工具。使用起来相当的方便，安装gvm使用如下命令： - - bash < <(curl -s https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer) - -安装完成后我们就可以安装go了： - - gvm install go1.0.3 - gvm use go1.0.3 - -执行完上面的命令之后GOPATH、GOROOT等环境变量会自动设置好，这样就可以直接使用了。 - -### apt-get -Ubuntu是目前使用最多的Linux桌面系统，使用`apt-get`命令来管理软件包，我们可以通过下面的命令来安装Go： - - sudo add-apt-repository ppa:gophers/go - sudo apt-get update - sudo apt-get install golang-stable - -### homebrew -homebrew是Mac系统下面目前使用最多的管理软件的工具，目前已支持Go，可以通过命令直接安装Go： - - brew install go - - -## links - * [目录]() - * 上一节: [Go环境配置](<1.md>) - * 下一节: [GOPATH 与工作空间](<1.2.md>) - -[downlink]: http://code.google.com/p/go/downloads/list "Go安装包下载" -[hg]: http://mercurial.selenic.com/downloads/ "Mercurial下载" +# 1.1 Go 安装 + +## Go的三种安装方式 +Go有多种安装方式，你可以选择自己喜欢的。这里我们介绍三种最常见的安装方式： + +- 从编译源码安装：这是一种标准的软件安装方式。对于经常使用Unix类系统的用户，尤其对于开发者来说，从源码安装是最方便而熟悉的。 +- 安装Go标准包：Go提供了方便的安装包，支持Windows、Linux、Mac等系统。这种方式适合初学者，可根据自己的系统位数下载好相应的安装包，一路next就可以轻松安装了。 +- 用软件包管理工具：目前有很多方便的第三方软件包工具，例如Ubuntu的apt-get、Mac的homebrew等。这种安装方式适合那些熟悉相应系统的用户。 + +最后，如果你想在同一个系统中安装多个版本的Go，你可以参考第三方工具[GVM](https://github.com/moovweb/gvm)，这是目前在这方面做得最好的工具，除非你知道怎么处理。 + +### Go源码安装 +在Go的源代码中，有些部分是用Plan 9 C和AT&T汇编写的，因此假如你要想从源码安装，就必须安装C的编译工具。 + +在Mac系统中，只要你安装了Xcode，就已经包含了相应的编译工具。 + +在类Unix系统中，需要安装gcc等工具。例如Ubuntu系统可通过在终端中执行`sudo apt-get install gcc libc6-dev`来安装编译工具。 + +在Windows系统中，你需要安装MinGW，然后通过MinGW安装gcc，并设置相应的环境变量。 + +Go使用[Mercurial][hg]进行版本管理，首先你必须安装了Mercurial，然后才能下载。假设你已经安装好Mercurial，执行如下代码： + +假设已经位于Go的安装目录 `$GO_INSTALL_DIR`下 + + hg clone -u release https://code.google.com/p/go + cd go/src + ./all.bash + +运行all.bash后出现"ALL TESTS PASSED"字样时才算安装成功。 + +上面是Unix风格的命令，Windows下的安装方式类似，只不过是运行all.bat，调用的编译器是MinGW的gcc。 + +然后设置几个环境变量， + + export GOROOT=$HOME/go + export GOBIN=$GOROOT/bin + export PATH=$PATH:$GOBIN + +看到如下图片即说明你已经安装成功 + +![](images/1.1.mac.png?raw=true) + +如果出现Go的Usage信息，那么说明Go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了Go的安装目录。 + + +## Go标准包安装 + +Go提供了每个平台打好包的一键安装，这些包默认会安装到如下目录：/usr/local/go (Windows系统：c:\Go)，当然你可以改变他们的安装位置，但是改变之后你必须在你的环境变量中设置如下信息： + + export GOROOT=$HOME/go + export PATH=$PATH:$GOROOT/bin + +### 如何判断自己的操作系统是32位还是64位？ + +我们接下来的Go安装需要判断操作系统的位数，所以这小节我们先确定自己的系统类型。 + +Windows系统用户请按Win+R运行cmd，输入`systeminfo`后回车，稍等片刻，会出现一些系统信息。在“系统类型”一行中，若显示“x64-based PC”，即为64位系统；若显示“X86-based PC”，则为32位系统。 + +Mac系统用户建议直接使用64位的，因为Go所支持的Mac OS X版本已经不支持纯32位处理器了。 + +Linux系统用户可通过在Terminal中执行命令`uname -a`来查看系统信息： + +64位系统显示 + + <一段描述> x86_64 x86_64 x86_64 GNU/Linux + //有些机器显示如下，例如ubuntu10.04 + x86_64 GNU/Linux + +32位系统显示 + + <一段描述> i686 i686 i386 GNU/Linux + +### Mac 安装 + +访问[下载地址][downlink]，32位系统下载go1.0.3.darwin-386.pkg，64位系统下载go1.0.3.darwin-amd64.pkg，双击下载文件，一路默认安装点击下一步，这个时候go已经安装到你的系统中，默认已经在PATH中增加了相应的`~/go/bin`,这个时候打开终端，输入`go` + +看到如下图片说明已经安装成功 + +![](images/1.1.mac.png?raw=true) + +如果出现go的Usage信息，那么说明go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了go的安装目录。 + +### Linux 安装 + +访问[下载地址][downlink]，32位系统下载go1.0.3.linux-386.tar.gz，64位系统下载go1.0.3.linux-amd64.tar.gz， + +假定你想要安装Go的目录为 `$GO_INSTALL_DIR`，后面替换为相应的目录路径。 + +解压缩`tar.gz`包到安装目录下：`tar zxvf go1.0.3.linux-amd64.tar.gz -C $GO_INSTALL_DIR`。 + +设置PATH，`export PATH=$PATH:$GO_INSTALL_DIR/go/bin` + +然后执行`go` + +看到类似上面mac安装成功的图片说明已经安装成功 + +如果出现go的Usage信息，那么说明go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了go的安装目录。 + +### Windows 安装 + +访问[下载地址][downlink]，32位系统下载go1.0.3.windows-386.msi，64位系统下载go1.0.3.windows-amd64.msi。双击打开下载的文件，一路按照默认点击下一步，这个时候go已经安装到你的系统中，默认安装之后已经在你的系统环境变量中加入了`c:/go/bin`，这个时候打开cmd，输入`go` + +看到类似上面mac安装成功的图片说明已经安装成功 + +如果出现Go的Usage信息，那么说明Go已经安装成功了；如果出现该命令不存在，那么可以检查一下自己的PATH环境变中是否包含了Go的安装目录。 + +## 第三方工具安装 +### GVM +gvm是第三方开发的Go多版本管理工具，类似ruby里面的rvm工具。使用起来相当的方便，安装gvm使用如下命令： + + bash < <(curl -s https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer) + +安装完成后我们就可以安装go了： + + gvm install go1.0.3 + gvm use go1.0.3 + +执行完上面的命令之后GOPATH、GOROOT等环境变量会自动设置好，这样就可以直接使用了。 + +### apt-get +Ubuntu是目前使用最多的Linux桌面系统，使用`apt-get`命令来管理软件包，我们可以通过下面的命令来安装Go： + + sudo add-apt-repository ppa:gophers/go + sudo apt-get update + sudo apt-get install golang-stable + +### homebrew +homebrew是Mac系统下面目前使用最多的管理软件的工具，目前已支持Go，可以通过命令直接安装Go： + + brew install go + + +## links + * [目录]() + * 上一节: [Go环境配置](<1.md>) + * 下一节: [GOPATH 与工作空间](<1.2.md>) + +[downlink]: http://code.google.com/p/go/downloads/list "Go安装包下载" +[hg]: http://mercurial.selenic.com/downloads/ "Mercurial下载" diff --git a/1.2.md b/1.2.md index 1f5db4c7..1800954b 100644 --- a/1.2.md +++ b/1.2.md @@ -70,6 +70,7 @@ GOPATH允许多个目录，当有多个目录时，请注意分隔符，多个GO cd $GOPATH/src mkdir mathapp + cd mathapp vim main.go // `$GOPATH/src/mathapp/main.go`源码： diff --git a/1.3.md b/1.3.md index cf51e55c..088812df 100644 --- a/1.3.md +++ b/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 diff --git a/1.4.md b/1.4.md index cd68e901..5b30cb69 100644 --- a/1.4.md +++ b/1.4.md @@ -1,301 +1,303 @@ -# 1.4 Go开发工具 - -本节我将介绍几个开发工具，它们都具有自动化提示，自动化fmt功能。因为它们都是跨平台的，所以安装步骤之类的都是通用的。 - -## LiteIDE - - LiteIDE是一款专门为Go语言开发的集成开发环境（IDE），由visualfc编写。支持项目管理、集成构建、GDB调试、语法高亮、自动补全、大纲显示等功能。下载地址: [http://code.google.com/p/golangide/downloads/list](http://code.google.com/p/golangide/downloads/list)，根据自己的系统下载相应的发行版本。Windows和Ubuntu系统可直接打开bin下面的liteide；Mac则需通过LaunchPad打开LiteIDE.app。 - - ![](images/1.4.liteide.png?raw=true) - - LiteIDE配置需要按照前面几个小节配置了相应的go和`$GOPATH`（LiteIDE中也可以图形化配置LiteIDE专用的GOPATH）。LiteIDE当前的编译环境可以通过编译工具栏上的环境配置来切换，如切换32位和64位，针对自己的系统，可能需要修改相应的LiteEnv环境变量，如64位版本，LiteIDE => 查看 => 选项 => LiteEnv => Win64.env => GOROOT=c:\go-w64 为你的`$GOROOT`，不然会无法使用`build`命令。 - - 配置好LiteIDE后，可以打开或拖动任何目录到LiteIDE中作为项目，LiteIDE的编译是针对当前编辑文档所属目录来执行相应的go命令，所以编译时要先打开相应的Go文件。LiteIDE仿IDEA界面，支持项目浏览、文件系统，Package浏览、Golang文档检索、类视图、大纲显示等多个工具窗口的切换。 - - 代码补全需要安装gocode，目前LiteIDE的自动化提示只支持本文件中函数的提示，还没有做到整个项目中函数的提示。 - - -## Sublime Text - - 这里将介绍Sublime Text 2（以下简称Sublime）+GoSublime+gocode+MarGo的组合，那么为什么选择这个组合呢？ - - - 自动化提示代码,如下图所示 - ![](images/1.4.sublime1.png?raw=true) - - - 保存的时候自动格式化代码，让您编写的代码更加美观，符合Go的标准。 - - 支持项目管理 - ![](images/1.4.sublime2.png?raw=true) - - 支持语法高亮 - - Sublime Text 2可免费使用，只是保存次数达到一定数量之后就会提示是否购买，点击取消继续用，和正式注册版本没有任何区别。 - - 接下来就开始讲如何安装，下载[Sublime](http://www.sublimetext.com/) - - 根据自己相应的系统下载相应的版本，然后打开Sublime，对于不熟悉Sublime的同学可以先看一下这篇文章[Sublime Text 2 入门及技巧](http://lucifr.com/139225/sublime-text-2-tricks-and-tips/) - - 1. 打开之后安装 Package Control：Ctrl+` 打开命令行，执行如下代码： - - import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Please restart Sublime Text to finish installation' - - 这个时候重启一下Sublime，可以发现在在菜单栏多了一个如下的栏目，说明Package Control已经安装成功了。 - - ![](images/1.4.sublime3.png?raw=true) - - 2. 接下来安装gocode和MarGo。 - 打开终端运行如下代码（需要git） - - go get -u github.com/nsf/gocode - go get -u github.com/DisposaBoy/MarGo - - 这个时候我们会发现在`$GOPATH/bin`下面多了两个可执行文件，gocode和MarGo，这两个文件会在GoSublime加载时自动启动。 - - 3. 安装完之后就可以安装Sublime的插件了。需安装GoSublime、SidebarEnhancements和Go Build，安装插件之后记得重启Sublime生效，Ctrl+Shift+p打开Package Controll 输入`pcip`（即“Package Control: Install Package”的缩写）。 - - 这个时候看左下角显示正在读取包数据，完成之后出现如下界面 - - ![](images/1.4.sublime4.png?raw=true) - - 这个时候输入GoSublime，按确定就开始安装了。同理应用于SidebarEnhancements和Go Build。 - - 4. 验证是否安装成功，你可以打开Sublime，打开main.go，看看语法是不是高亮了，输入`import`是不是自动化提示了，`import "fmt"`之后，输入`fmt.`是不是自动化提示有函数了。 - - 如果已经出现这个提示，那说明你已经安装完成了，并且完成了自动提示。 - - 如果没有出现这样的提示，一般就是你的`$PATH`没有配置正确。你可以打开终端，输入gocode，是不是能够正确运行，如果不行就说明`$PATH`没有配置正确。 - - -## Vim -Vim是从vi发展出来的一个文本编辑器, 代码补全、编译及错误跳转等方便编程的功能特别丰富，在程序员中被广泛使用。 - - ![](images/1.4.vim.png?raw=true) - - 1. 配置vim高亮显示 - - cp -r $GOROOT/misc/vim/* ~/.vim/ - - 2. 在~/.vimrc文件中增加语法高亮显示 - - filetype plugin indent on - syntax on - - 3. 安装[Gocode](https://github.com/nsf/gocode/) - - go get -u github.com/nsf/gocode - - gocode默认安装到`$GOPATH/bin`下面，需要把`$GOPATH/bin`路径设置到系统`$PATH`里面。 - - 4. 配置[Gocode](https://github.com/nsf/gocode/) - - ~ cd $GOPATH/src/github.com/nsf/gocode/vim - ~ ./update.bash - ~ gocode set propose-builtins true - propose-builtins true - ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64" - lib-path "/home/border/gocode/pkg/linux_amd64" - ~ gocode set - propose-builtins true - lib-path "/home/border/gocode/pkg/linux_amd64" - ->gocode set里面的两个参数的含意说明： -> ->propose-builtins：是否自动提示Go的内置函数、类型和常量，默认为false，不提示。 -> ->lib-path:默认情况下，gocode只会搜索**$GOPATH/pkg/$GOOS_$GOARCH** 和 **$GOROOT/pkg/$GOOS_$GOARCH**目录下的包，当然这个设置就是可以设置我们额外的lib能访问的路径 - - - - 5. 恭喜你，安装完成，你现在可以使用`:e main.go`体验一下开发Go的乐趣。 - - -## Emacs -Emacs传说中的神器，她不仅仅是一个编辑器，它是一个整合环境，或可称它为集成开发环境，这些功能如让使用者置身于全功能的操作系统中。 - - ![](images/1.4.emacs.png?raw=true) - - 1. 配置Emacs高亮显示 - - cp $GOROOT/misc/emacs/* ~/.emacs.d/ - - 2. 安装[Gocode](https://github.com/nsf/gocode/) - - go get -u github.com/nsf/gocode - - gocode默认安装到`$GOPATH/bin`里面下面，需要把`$GOPATH/bin`路径设置到系统`$PATH`里面。 - - 3. 配置[Gocode](https://github.com/nsf/gocode/) - - - ~ cd $GOPATH/src/github.com/nsf/gocode/emacs - ~ cp go-autocomplete.el ~/.emacs.d/ - ~ gocode set propose-builtins true - propose-builtins true - ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64" // 换为你自己的路径 - lib-path "/home/border/gocode/pkg/linux_amd64" - ~ gocode set - propose-builtins true - lib-path "/home/border/gocode/pkg/linux_amd64" - - 4. 需要安装 [Auto Completion](http://www.emacswiki.org/emacs/AutoComplete) - - 下载AutoComplete并解压 - - ~ make install DIR=$HOME/.emacs.d/auto-complete - - 配置~/.emacs文件 - - ;;auto-complete - (require 'auto-complete-config) - (add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict") - (ac-config-default) - (local-set-key (kbd "M-/") 'semantic-complete-analyze-inline) - (local-set-key "." 'semantic-complete-self-insert) - (local-set-key ">" 'semantic-complete-self-insert) - - 详细信息参考: http://www.emacswiki.org/emacs/AutoComplete - - 5. 配置.emacs - - ;; golang mode - (require 'go-mode-load) - (require 'go-autocomplete) - ;; speedbar - ;; (speedbar 1) - (speedbar-add-supported-extension ".go") - (add-hook - 'go-mode-hook - '(lambda () - ;; gocode - (auto-complete-mode 1) - (setq ac-sources '(ac-source-go)) - ;; Imenu & Speedbar - (setq imenu-generic-expression - '(("type" "^type *\\([^ \t\n\r\f]*\\)" 1) - ("func" "^func *\\(.*\\) {" 1))) - (imenu-add-to-menubar "Index") - ;; Outline mode - (make-local-variable 'outline-regexp) - (setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....") - (outline-minor-mode 1) - (local-set-key "\M-a" 'outline-previous-visible-heading) - (local-set-key "\M-e" 'outline-next-visible-heading) - ;; Menu bar - (require 'easymenu) - (defconst go-hooked-menu - '("Go tools" - ["Go run buffer" go t] - ["Go reformat buffer" go-fmt-buffer t] - ["Go check buffer" go-fix-buffer t])) - (easy-menu-define - go-added-menu - (current-local-map) - "Go tools" - go-hooked-menu) - - ;; Other - (setq show-trailing-whitespace t) - )) - ;; helper function - (defun go () - "run current buffer" - (interactive) - (compile (concat "go run " (buffer-file-name)))) - - ;; helper function - (defun go-fmt-buffer () - "run gofmt on current buffer" - (interactive) - (if buffer-read-only - (progn - (ding) - (message "Buffer is read only")) - (let ((p (line-number-at-pos)) - (filename (buffer-file-name)) - (old-max-mini-window-height max-mini-window-height)) - (show-all) - (if (get-buffer "*Go Reformat Errors*") - (progn - (delete-windows-on "*Go Reformat Errors*") - (kill-buffer "*Go Reformat Errors*"))) - (setq max-mini-window-height 1) - (if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t)) - (progn - (erase-buffer) - (insert-buffer-substring "*Go Reformat Output*") - (goto-char (point-min)) - (forward-line (1- p))) - (with-current-buffer "*Go Reformat Errors*" - (progn - (goto-char (point-min)) - (while (re-search-forward "" nil t) - (replace-match filename)) - (goto-char (point-min)) - (compilation-mode)))) - (setq max-mini-window-height old-max-mini-window-height) - (delete-windows-on "*Go Reformat Output*") - (kill-buffer "*Go Reformat Output*")))) - ;; helper function - (defun go-fix-buffer () - "run gofix on current buffer" - (interactive) - (show-all) - (shell-command-on-region (point-min) (point-max) "go tool fix -diff")) - - 6. 恭喜你，你现在可以体验在神器中开发Go的乐趣。默认speedbar是关闭的，如果打开需要把 ;; (speedbar 1) 前面的注释去掉，或者也可以通过 *M-x speedbar* 手动开启。 - -## Eclipse -Eclipse也是非常常用的开发利器，以下介绍如何使用Eclipse来编写Go程序。 - - ![](images/1.4.eclipse1.png?raw=true) - - 1.首先下载并安装好[Eclipse](http://www.eclipse.org/) - - 2.下载[goeclipse](https://code.google.com/p/goclipse/)插件 - - http://code.google.com/p/goclipse/wiki/InstallationInstructions - - 3.下载gocode，用于go的代码补全提示 - -gocode的github地址： - - https://github.com/nsf/gocode - -在windows下要安装git，通常用[msysgit](https://code.google.com/p/msysgit/) - -再在cmd下安装： - - go get -u github.com/nsf/gocode - -也可以下载代码，直接用go build来编译，会生成gocode.exe - - 4.下载[MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)并按要求装好 - - 5.配置插件 - - Windows->Reference->Go - - (1).配置Go的编译器 - - ![](images/1.4.eclipse2.png?raw=true) - - (2).配置Gocode（可选，代码补全），设置Gocode路径为之前生成的gocode.exe文件 - - ![](images/1.4.eclipse3.png?raw=true) - - (3).配置GDB（可选，做调试用），设置GDB路径为MingW安装目录下的gdb.exe文件 - - ![](images/1.4.eclipse4.png?raw=true) - - 6.测试是否成功 - -新建一个go工程，再建立一个hello.go。如下图： - - ![](images/1.4.eclipse5.png?raw=true) - -调试如下（要在console中用输入命令来调试）： - - ![](images/1.4.eclipse6.png?raw=true) - - -## links - * [目录]() - * 上一节: [Go 命令](<1.3.md>) - * 下一节: [总结](<1.5.md>) +# 1.4 Go开发工具 + +本节我将介绍几个开发工具，它们都具有自动化提示，自动化fmt功能。因为它们都是跨平台的，所以安装步骤之类的都是通用的。 + +## LiteIDE + + LiteIDE是一款专门为Go语言开发的集成开发环境（IDE），由visualfc编写。支持项目管理、集成构建、GDB调试、语法高亮、自动补全、大纲显示等功能。下载地址: [http://code.google.com/p/golangide/downloads/list](http://code.google.com/p/golangide/downloads/list)，根据自己的系统下载相应的发行版本。Windows和Ubuntu系统可直接打开bin下面的liteide；Mac则需通过LaunchPad打开LiteIDE.app。 + + ![](images/1.4.liteide.png?raw=true) + + LiteIDE配置需要按照前面几个小节配置了相应的go和`$GOPATH`（LiteIDE中也可以图形化配置LiteIDE专用的GOPATH）。LiteIDE当前的编译环境可以通过编译工具栏上的环境配置来切换，如切换32位和64位，针对自己的系统，可能需要修改相应的LiteEnv环境变量，如64位版本，LiteIDE => 查看 => 选项 => LiteEnv => Win64.env => GOROOT=c:\go-w64 为你的`$GOROOT`，不然会无法使用`build`命令。 + + 配置好LiteIDE后，可以打开或拖动任何目录到LiteIDE中作为项目，LiteIDE的编译是针对当前编辑文档所属目录来执行相应的go命令，所以编译时要先打开相应的Go文件。LiteIDE仿IDEA界面，支持项目浏览、文件系统，Package浏览、Golang文档检索、类视图、大纲显示等多个工具窗口的切换。 + + 代码补全需要安装gocode: + + go get github.com/nsf/gocode + + +## Sublime Text + + 这里将介绍Sublime Text 2（以下简称Sublime）+GoSublime+gocode+MarGo的组合，那么为什么选择这个组合呢？ + + - 自动化提示代码,如下图所示 + ![](images/1.4.sublime1.png?raw=true) + + - 保存的时候自动格式化代码，让您编写的代码更加美观，符合Go的标准。 + - 支持项目管理 + ![](images/1.4.sublime2.png?raw=true) + - 支持语法高亮 + - Sublime Text 2可免费使用，只是保存次数达到一定数量之后就会提示是否购买，点击取消继续用，和正式注册版本没有任何区别。 + + 接下来就开始讲如何安装，下载[Sublime](http://www.sublimetext.com/) + + 根据自己相应的系统下载相应的版本，然后打开Sublime，对于不熟悉Sublime的同学可以先看一下这篇文章[Sublime Text 2 入门及技巧](http://lucifr.com/139225/sublime-text-2-tricks-and-tips/) + + 1. 打开之后安装 Package Control：Ctrl+` 打开命令行，执行如下代码： + + import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Please restart Sublime Text to finish installation' + + 这个时候重启一下Sublime，可以发现在在菜单栏多了一个如下的栏目，说明Package Control已经安装成功了。 + + ![](images/1.4.sublime3.png?raw=true) + + 2. 接下来安装gocode和MarGo。 + 打开终端运行如下代码（需要git） + + go get github.com/nsf/gocode + go get github.com/DisposaBoy/MarGo + + 这个时候我们会发现在`$GOPATH/bin`下面多了两个可执行文件，gocode和MarGo，这两个文件会在GoSublime加载时自动启动。 + + 3. 安装完之后就可以安装Sublime的插件了。需安装GoSublime、SidebarEnhancements和Go Build，安装插件之后记得重启Sublime生效，Ctrl+Shift+p打开Package Controll 输入`pcip`（即“Package Control: Install Package”的缩写）。 + + 这个时候看左下角显示正在读取包数据，完成之后出现如下界面 + + ![](images/1.4.sublime4.png?raw=true) + + 这个时候输入GoSublime，按确定就开始安装了。同理应用于SidebarEnhancements和Go Build。 + + 4. 验证是否安装成功，你可以打开Sublime，打开main.go，看看语法是不是高亮了，输入`import`是不是自动化提示了，`import "fmt"`之后，输入`fmt.`是不是自动化提示有函数了。 + + 如果已经出现这个提示，那说明你已经安装完成了，并且完成了自动提示。 + + 如果没有出现这样的提示，一般就是你的`$PATH`没有配置正确。你可以打开终端，输入gocode，是不是能够正确运行，如果不行就说明`$PATH`没有配置正确。 + + +## Vim +Vim是从vi发展出来的一个文本编辑器, 代码补全、编译及错误跳转等方便编程的功能特别丰富，在程序员中被广泛使用。 + + ![](images/1.4.vim.png?raw=true) + + 1. 配置vim高亮显示 + + cp -r $GOROOT/misc/vim/* ~/.vim/ + + 2. 在~/.vimrc文件中增加语法高亮显示 + + filetype plugin indent on + syntax on + + 3. 安装[Gocode](https://github.com/nsf/gocode/) + + go get -u github.com/nsf/gocode + + gocode默认安装到`$GOBIN`下面。 + + 4. 配置[Gocode](https://github.com/nsf/gocode/) + + ~ cd $GOPATH/src/github.com/nsf/gocode/vim + ~ ./update.bash + ~ gocode set propose-builtins true + propose-builtins true + ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64" + lib-path "/home/border/gocode/pkg/linux_amd64" + ~ gocode set + propose-builtins true + lib-path "/home/border/gocode/pkg/linux_amd64" + +>gocode set里面的两个参数的含意说明： +> +>propose-builtins：是否自动提示Go的内置函数、类型和常量，默认为false，不提示。 +> +>lib-path:默认情况下，gocode只会搜索**$GOPATH/pkg/$GOOS_$GOARCH** 和 **$GOROOT/pkg/$GOOS_$GOARCH**目录下的包，当然这个设置就是可以设置我们额外的lib能访问的路径 + + + + 5. 恭喜你，安装完成，你现在可以使用`:e main.go`体验一下开发Go的乐趣。 + + +## Emacs +Emacs传说中的神器，她不仅仅是一个编辑器，它是一个整合环境，或可称它为集成开发环境，这些功能如让使用者置身于全功能的操作系统中。 + + ![](images/1.4.emacs.png?raw=true) + + 1. 配置Emacs高亮显示 + + cp $GOROOT/misc/emacs/* ~/.emacs.d/ + + 2. 安装[Gocode](https://github.com/nsf/gocode/) + + go get -u github.com/nsf/gocode + + gocode默认安装到`$GOBIN`里面下面。 + + 3. 配置[Gocode](https://github.com/nsf/gocode/) + + + ~ cd $GOPATH/src/github.com/nsf/gocode/emacs + ~ cp go-autocomplete.el ~/.emacs.d/ + ~ gocode set propose-builtins true + propose-builtins true + ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64" // 换为你自己的路径 + lib-path "/home/border/gocode/pkg/linux_amd64" + ~ gocode set + propose-builtins true + lib-path "/home/border/gocode/pkg/linux_amd64" + + 4. 需要安装 [Auto Completion](http://www.emacswiki.org/emacs/AutoComplete) + + 下载AutoComplete并解压 + + ~ make install DIR=$HOME/.emacs.d/auto-complete + + 配置~/.emacs文件 + + ;;auto-complete + (require 'auto-complete-config) + (add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict") + (ac-config-default) + (local-set-key (kbd "M-/") 'semantic-complete-analyze-inline) + (local-set-key "." 'semantic-complete-self-insert) + (local-set-key ">" 'semantic-complete-self-insert) + + 详细信息参考: http://www.emacswiki.org/emacs/AutoComplete + + 5. 配置.emacs + + ;; golang mode + (require 'go-mode-load) + (require 'go-autocomplete) + ;; speedbar + ;; (speedbar 1) + (speedbar-add-supported-extension ".go") + (add-hook + 'go-mode-hook + '(lambda () + ;; gocode + (auto-complete-mode 1) + (setq ac-sources '(ac-source-go)) + ;; Imenu & Speedbar + (setq imenu-generic-expression + '(("type" "^type *\\([^ \t\n\r\f]*\\)" 1) + ("func" "^func *\\(.*\\) {" 1))) + (imenu-add-to-menubar "Index") + ;; Outline mode + (make-local-variable 'outline-regexp) + (setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....") + (outline-minor-mode 1) + (local-set-key "\M-a" 'outline-previous-visible-heading) + (local-set-key "\M-e" 'outline-next-visible-heading) + ;; Menu bar + (require 'easymenu) + (defconst go-hooked-menu + '("Go tools" + ["Go run buffer" go t] + ["Go reformat buffer" go-fmt-buffer t] + ["Go check buffer" go-fix-buffer t])) + (easy-menu-define + go-added-menu + (current-local-map) + "Go tools" + go-hooked-menu) + + ;; Other + (setq show-trailing-whitespace t) + )) + ;; helper function + (defun go () + "run current buffer" + (interactive) + (compile (concat "go run " (buffer-file-name)))) + + ;; helper function + (defun go-fmt-buffer () + "run gofmt on current buffer" + (interactive) + (if buffer-read-only + (progn + (ding) + (message "Buffer is read only")) + (let ((p (line-number-at-pos)) + (filename (buffer-file-name)) + (old-max-mini-window-height max-mini-window-height)) + (show-all) + (if (get-buffer "*Go Reformat Errors*") + (progn + (delete-windows-on "*Go Reformat Errors*") + (kill-buffer "*Go Reformat Errors*"))) + (setq max-mini-window-height 1) + (if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t)) + (progn + (erase-buffer) + (insert-buffer-substring "*Go Reformat Output*") + (goto-char (point-min)) + (forward-line (1- p))) + (with-current-buffer "*Go Reformat Errors*" + (progn + (goto-char (point-min)) + (while (re-search-forward "" nil t) + (replace-match filename)) + (goto-char (point-min)) + (compilation-mode)))) + (setq max-mini-window-height old-max-mini-window-height) + (delete-windows-on "*Go Reformat Output*") + (kill-buffer "*Go Reformat Output*")))) + ;; helper function + (defun go-fix-buffer () + "run gofix on current buffer" + (interactive) + (show-all) + (shell-command-on-region (point-min) (point-max) "go tool fix -diff")) + + 6. 恭喜你，你现在可以体验在神器中开发Go的乐趣。默认speedbar是关闭的，如果打开需要把 ;; (speedbar 1) 前面的注释去掉，或者也可以通过 *M-x speedbar* 手动开启。 + +## Eclipse +Eclipse也是非常常用的开发利器，以下介绍如何使用Eclipse来编写Go程序。 + + ![](images/1.4.eclipse1.png?raw=true) + + 1.首先下载并安装好[Eclipse](http://www.eclipse.org/) + + 2.下载[goeclipse](https://code.google.com/p/goclipse/)插件 + + http://code.google.com/p/goclipse/wiki/InstallationInstructions + + 3.下载gocode，用于go的代码补全提示 + +gocode的github地址： + + https://github.com/nsf/gocode + +在windows下要安装git，通常用[msysgit](https://code.google.com/p/msysgit/) + +再在cmd下安装： + + go get -u github.com/nsf/gocode + +也可以下载代码，直接用go build来编译，会生成gocode.exe + + 4.下载[MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)并按要求装好 + + 5.配置插件 + + Windows->Reference->Go + + (1).配置Go的编译器 + + ![](images/1.4.eclipse2.png?raw=true) + + (2).配置Gocode（可选，代码补全），设置Gocode路径为之前生成的gocode.exe文件 + + ![](images/1.4.eclipse3.png?raw=true) + + (3).配置GDB（可选，做调试用），设置GDB路径为MingW安装目录下的gdb.exe文件 + + ![](images/1.4.eclipse4.png?raw=true) + + 6.测试是否成功 + +新建一个go工程，再建立一个hello.go。如下图： + + ![](images/1.4.eclipse5.png?raw=true) + +调试如下（要在console中用输入命令来调试）： + + ![](images/1.4.eclipse6.png?raw=true) + + +## links + * [目录]() + * 上一节: [Go 命令](<1.3.md>) + * 下一节: [总结](<1.5.md>) diff --git a/11.3.md b/11.3.md index 639437b7..45ee14e4 100644 --- a/11.3.md +++ b/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 diff --git a/12.1.md b/12.1.md index 9786c643..ffeea4b9 100644 --- a/12.1.md +++ b/12.1.md @@ -1,6 +1,166 @@ -# 12.1 应用日志 - -## links - * [目录]() - * 上一章: [部署与维护](<12.md>) +# 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 := ` + + + + + + + + + + + + + + + + + ` + 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配置用来发送邮件： + + + + + +邮件的格式通过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 + * [目录]() + * 上一章: [部署与维护](<12.md>) * 下一节: [网站错误处理](<12.2.md>) \ No newline at end of file diff --git a/12.2.md b/12.2.md index 683cd3ae..7a146efa 100644 --- a/12.2.md +++ b/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，下面分别显示了错误页面的源码： + + + + + 找不到页面 + + + + +
+
+
+
+

404!

+

{{.ErrorInfo}}

+
+
+
+
+ + + 另一个源码： + + + + + 系统错误页面 + + + + +
+
+
+
+

系统暂时不可用!

+

{{.ErrorInfo}}

+
+
+
+
+ + + + 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 * [目录]() * 上一章: [应用日志](<12.1.md>) diff --git a/12.3.md b/12.3.md index b587e7eb..c5b3c23b 100644 --- a/12.3.md +++ b/12.3.md @@ -1,6 +1,181 @@ -# 12.3 应用部署 - -## links - * [目录]() - * 上一章: [网站错误处理](<12.2.md>) +# 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 + * [目录]() + * 上一章: [网站错误处理](<12.2.md>) * 下一节: [备份和恢复](<12.4.md>) \ No newline at end of file diff --git a/12.4.md b/12.4.md index 406a3920..0cf69a5a 100644 --- a/12.4.md +++ b/12.4.md @@ -1,5 +1,173 @@ # 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 < $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 * [目录]() * 上一章: [应用部署](<12.3.md>) diff --git a/12.5.md b/12.5.md index 2b3296b8..8bd84a26 100644 --- a/12.5.md +++ b/12.5.md @@ -1,4 +1,16 @@ # 12.5 小结 +本章讨论了如何部署和维护我们开发的Web应用相关的一些话题。这些内容非常重要，要创建一个能够基于最小维护平滑运行的应用，必须考虑这些问题。 + +具体而言，本章讨论的内容包括： + +- 创建一个强健的日志系统，可以在出现问题时记录错误并且通知系统管理员 +- 处理运行时可能出现的错误，包括记录日志，并如何友好的显示给用户系统出现了问题 +- 处理404错误，告诉用户请求的页面找不到 +- 将应用部署到一个生产环境中(包括如何部署更新) +- 如何让部署的应用程序具有高可用 +- 备份和恢复文件以及数据库 + +读完本章内容后，对于从头开始开发一个Web应用需要考虑那些问题，你应该已经有了全面的了解。本章内容将有助于你在实际环境中管理前面各章介绍开发的代码。 ## links * [目录]() diff --git a/12.md b/12.md index a59312e0..a074b376 100644 --- a/12.md +++ b/12.md @@ -1,5 +1,7 @@ # 12 部署与维护 +到目前为止，我们前面已经介绍了如何开发程序、调试程序以及测试程序，正如人们常说的：开发最后的10%需要花费90%的时间，所以这一章我们将强调这最后的10%部分，要真正成为让人信任并使用的优秀应用，需要考虑到一些细节，以上所说的10%就是指这些小细节。 +本章我们将通过四个小节来介绍这些小细节的处理，第一小节介绍如何在生产服务上记录程序产生的日志，如何记录日志，第二小节介绍发生错误时我们的程序如何处理，如何保证尽量少的影响到用户的访问，第三小节介绍如何来部署Go的独立程序，由于目前Go程序还无法像C那样写成daemon，那么我们如何管理这样的进程程序后台运行呢？第四小节讲介绍应用数据的备份和恢复，尽量保证应用在奔溃的情况能够保持数据的完整性。 ## 目录 * 1 [应用日志](12.1.md) * 2 [网站错误处理](12.2.md) diff --git a/13.1.md b/13.1.md new file mode 100644 index 00000000..ced462af --- /dev/null +++ b/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 + * [目录]() + * 上一章: [构建博客系统](<13.md>) + * 下一节: [自定义路由器设计](<13.2.md>) \ No newline at end of file diff --git a/13.2.md b/13.2.md new file mode 100644 index 00000000..a6988183 --- /dev/null +++ b/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 + * [目录]() + * 上一章: [数据库设计](<13.2.md>) + * 下一节: [controller设计](<13.4.md>) \ No newline at end of file diff --git a/13.3.md b/13.3.md new file mode 100644 index 00000000..5997c640 --- /dev/null +++ b/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的代码如下所示，我们可以看到数据的设置和显示都是相当的简单方便： + + + + + beego welcome template + + +

Hello, world!{{.Username}},{{.Email}}

+ + + + +## links + * [目录]() + * 上一章: [自定义路由器设计](<13.2.md>) + * 下一节: [日志和配置设计](<13.4.md>) \ No newline at end of file diff --git a/13.4.md b/13.4.md new file mode 100644 index 00000000..8289e0af --- /dev/null +++ b/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 + * [目录]() + * 上一章: [controller设计](<13.3.md>) + * 下一节: [实现博客的增删改](<13.5.md>) \ No newline at end of file diff --git a/13.5.md b/13.5.md new file mode 100644 index 00000000..f0be299d --- /dev/null +++ b/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 + + + + My Blog + + + + + + + {{.LayoutContent}} + + + + +index.tpl + +

Blog posts

+ + + +view.tpl + +

{{.Post.Title}}

+ {{.Post.Created}}
+ + {{.Post.Content}} + +new.tpl + +

New Blog Post

+
+ 标题:
+ 内容： + +
+ +edit.tpl + +

Edit {{.Post.Title}}

+ +

New Blog Post

+
+ 标题:
+ 内容： + + +
+ +## links + * [目录]() + * 上一章: [数据库操作](<13.4.md>) + * 下一节: [小结](<13.6.md>) \ No newline at end of file diff --git a/13.6.md b/13.6.md new file mode 100644 index 00000000..b9041ce3 --- /dev/null +++ b/13.6.md @@ -0,0 +1,7 @@ +# 13.6 小结 +这一章我们主要介绍了如何实现一个基础的Go语言框架，框架包含有路由设计，由于Go内置的http包中路由的一些不足点，我们设计了动态路由规则，然后介绍了MVC模式中的Controller设计，controller实现了REST的实现，这个主要思路来源于tornado框架，然后设计实现了模板的layout以及自动化渲染等技术，主要采用了Go内置的模板引擎，最后我们介绍了一些辅助的日志、配置等信息的设计，通过这些设计我们实现了一个基础的框架beego，目前该框架已经开源在github，最后我们通过beego实现了一个博客系统，通过实例代码详细的展现了如何快速的开发一个站点。 + +## links + * [目录]() + * 上一章: [实现博客的增删改](<13.5.md>) + * 下一节: [扩展博客管理系统](<14.md>) \ No newline at end of file diff --git a/13.md b/13.md new file mode 100644 index 00000000..a0befe2d --- /dev/null +++ b/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 + * [目录]() + * 上一章: [第十二章总结](<12.5.md>) + * 下一节: [项目规划](<13.1.md>) \ No newline at end of file diff --git a/14.1.md b/14.1.md new file mode 100644 index 00000000..e69de29b diff --git a/14.2.md b/14.2.md new file mode 100644 index 00000000..e69de29b diff --git a/14.3.md b/14.3.md new file mode 100644 index 00000000..e69de29b diff --git a/14.4.md b/14.4.md new file mode 100644 index 00000000..e69de29b diff --git a/14.5.md b/14.5.md new file mode 100644 index 00000000..e69de29b diff --git a/14.6.md b/14.6.md new file mode 100644 index 00000000..e69de29b diff --git a/14.md b/14.md new file mode 100644 index 00000000..8bd98946 --- /dev/null +++ b/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 + * [目录]() + * 上一章: [第十三章总结](<13.6.md>) + * 下一节: [静态文件支持](<14.1.md>) \ No newline at end of file diff --git a/2.1.md b/2.1.md index a5031428..d68fc43b 100644 --- a/2.1.md +++ b/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`来组织的 diff --git a/2.2.md b/2.2.md index 80bab5ad..05c543f6 100644 --- a/2.2.md +++ b/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[:] // 等价于aSlice = array[0:9] 这样aSlice包含了全部的元素 + aSlice = array[5:] // 等价于aSlice = array[5:10] aSlice包含元素: f,g,h,i,j + aSlice = array[:] // 等价于aSlice = array[0:10] 这样aSlice包含了全部的元素 // 从slice中获取slice aSlice = array[3:7] // aSlice包含元素: d,e,f,g，len=4，cap=7 diff --git a/2.6.md b/2.6.md index a4c9b8c7..9e748108 100644 --- a/2.6.md +++ b/2.6.md @@ -234,91 +234,91 @@ interface的变量可以持有任意实现该interface类型的对象，这给 让我们通过一个例子来更加深入的理解。 - package main + package main - import ( - "fmt" - "strconv" - ) + import ( + "fmt" + "strconv" + ) - type Element interface{} - type List [] Element + type Element interface{} + type List [] Element - type Person struct { - name string - age int - } + type Person struct { + name string + age int + } - //定义了String方法，实现了fmt.Stringer - func (p Person) String() string { - return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)" - } + //定义了String方法，实现了fmt.Stringer + func (p Person) String() string { + return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)" + } - func main() { - list := make(List, 3) - list[0] = 1 // an int - list[1] = "Hello" // a string - list[2] = Person{"Dennis", 70} + func main() { + list := make(List, 3) + list[0] = 1 // an int + list[1] = "Hello" // a string + list[2] = Person{"Dennis", 70} - for index, element := range list { - if value, ok := element.(int); ok { - fmt.Printf("list[%d] is an int and its value is %d\n", index, value) - } else if value, ok := element.(string); ok { - fmt.Printf("list[%d] is a string and its value is %s\n", index, value) - } else if value, ok := element.(Person); ok { - fmt.Printf("list[%d] is a Person and its value is %s\n", index, value) - } else { - fmt.Println("list[%d] is of a different type", index) + for index, element := range list { + if value, ok := element.(int); ok { + fmt.Printf("list[%d] is an int and its value is %d\n", index, value) + } else if value, ok := element.(string); ok { + fmt.Printf("list[%d] is a string and its value is %s\n", index, value) + } else if value, ok := element.(Person); ok { + fmt.Printf("list[%d] is a Person and its value is %s\n", index, value) + } else { + fmt.Println("list[%d] is of a different type", index) + } } } - } -是不是很简单啊，同时你是否注意到了多个ifs里面，还记得我前面介绍流程里面讲过，if里面允许初始化变量。 + 是不是很简单啊，同时你是否注意到了多个ifs里面，还记得我前面介绍流程里面讲过，if里面允许初始化变量。 -也许你注意到了，我们断言的类型越多，那么ifelse也就越多，所以才引出了下面要介绍的switch。 + 也许你注意到了，我们断言的类型越多，那么ifelse也就越多，所以才引出了下面要介绍的switch。 - switch测试 -最好的讲解就是代码例子，现在让我们重写上面的这个实现 + 最好的讲解就是代码例子，现在让我们重写上面的这个实现 - package main + package main - import ( - "fmt" - "strconv" - ) + import ( + "fmt" + "strconv" + ) - type Element interface{} - type List [] Element + type Element interface{} + type List [] Element - type Person struct { - name string - age int - } + type Person struct { + name string + age int + } - //打印 - func (p Person) String() string { - return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)" - } + //打印 + func (p Person) String() string { + return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)" + } - func main() { - list := make(List, 3) - list[0] = 1 //an int - list[1] = "Hello" //a string - list[2] = Person{"Dennis", 70} + func main() { + list := make(List, 3) + list[0] = 1 //an int + list[1] = "Hello" //a string + list[2] = Person{"Dennis", 70} - for index, element := range list{ - switch value := element.(type) { - case int: - fmt.Printf("list[%d] is an int and its value is %d\n", index, value) - case string: - fmt.Printf("list[%d] is a string and its value is %s\n", index, value) - case Person: - fmt.Printf("list[%d] is a Person and its value is %s\n", index, value) - default: - fmt.Println("list[%d] is of a different type", index) + for index, element := range list{ + switch value := element.(type) { + case int: + fmt.Printf("list[%d] is an int and its value is %d\n", index, value) + case string: + fmt.Printf("list[%d] is a string and its value is %s\n", index, value) + case Person: + fmt.Printf("list[%d] is a Person and its value is %s\n", index, value) + default: + fmt.Println("list[%d] is of a different type", index) + } } } - } 这里有一点需要强调的是：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。 diff --git a/2.7.md b/2.7.md index ea296df1..006be415 100644 --- a/2.7.md +++ b/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 中读取一些元素，腾出空间。 diff --git a/3.3.md b/3.3.md index 4e78daf0..ae1ad63f 100644 --- a/3.3.md +++ b/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的信息反馈到客户端。 diff --git a/3.4.md b/3.4.md index 59738931..bca74e83 100644 --- a/3.4.md +++ b/3.4.md @@ -22,7 +22,7 @@ Go在等待客户端请求里面是这样写的： 它的结构如下： type ServeMux struct { - mu sync.RWMutex //锁，由于请求设计到并发处理，因此这里需要一个锁机制 + mu sync.RWMutex //锁，由于请求涉及到并发处理，因此这里需要一个锁机制 m map[string]muxEntry // 路由规则，一个string对应一个mux实体，这里的string就是注册的路由表达式 } diff --git a/4.1.md b/4.1.md index 956de5ef..00035562 100644 --- a/4.1.md +++ b/4.1.md @@ -1,6 +1,6 @@ # 4.1处理表单的输入 -我们先来看一个表单递交的例子，我们有如下的表单内容，命名成文件login.gtpl(放入当前新建项目的目录里面) +先来看一个表单递交的例子，我们有如下的表单内容，命名成文件login.gtpl(放入当前新建项目的目录里面) @@ -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) diff --git a/4.2.md b/4.2.md index 9113fb05..fdd6455e 100644 --- a/4.2.md +++ b/4.2.md @@ -1,6 +1,6 @@ # 4.2验证表单的输入 -我们开发Web的一个原则就是，不能信任用户输入的任何信息，所以验证和过滤用户的输入信息就变得非常重要，我们经常会在微博、新闻中听到某某网站被入侵了，存在什么漏洞，这些大多是是因为网站对于用户输入的信息没有做严格的验证引起的，所以为了编写出安全可靠的Web程序，验证表单输入的意义重大。 +开发Web的一个原则就是，不能信任用户输入的任何信息，所以验证和过滤用户的输入信息就变得非常重要，我们经常会在微博、新闻中听到某某网站被入侵了，存在什么漏洞，这些大多是是因为网站对于用户输入的信息没有做严格的验证引起的，所以为了编写出安全可靠的Web程序，验证表单输入的意义重大。 我们平常编写Web应用主要有两方面的数据验证，一个是在页面端的js验证(目前在这方面有很多的插件库，比如ValidationJS插件)，一个是在服务器端的验证，我们这小节讲解的是如何在服务器端验证。 diff --git a/5.2.md b/5.2.md index cfc2fbe2..e7575459 100644 --- a/5.2.md +++ b/5.2.md @@ -1,135 +1,137 @@ -# 5.2使用MySQL数据库 -目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。 - -## MySQL驱动 -Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: - -- http://code.google.com/p/go-mysql-driver/ 支持database/sql，全部采用go写。 -- https://github.com/ziutek/mymysql 支持database/sql，也支持自定义的接口，全部采用go写。 -- https://github.com/Philio/GoMySQL 不支持database/sql，自定义接口，全部采用go写。 - -接下来的例子我主要以第一个驱动为例(我目前项目中也是采用它来驱动)，也推荐大家采用它，主要理由： - -- 这个驱动比较新，维护的比较好 -- 完全支持database/sql接口 -- 支持keepalive，保持长连接,虽然[星星](http://www.mikespook.com)fork的mymysql也支持keepalive，但不是线程安全的，这个从底层就支持了keepalive。 - -## 示例代码 -接下来的几个小节里面我们都将采用同一个数据库表结构：数据库test，用户表userinfo，关联用户信息表userdetail。 - - CREATE TABLE `userinfo` ( - `uid` INT(10) NOT NULL AUTO_INCREMENT, - `username` VARCHAR(64) NULL DEFAULT NULL, - `departname` VARCHAR(64) NULL DEFAULT NULL, - `created` DATE NULL DEFAULT NULL, - PRIMARY KEY (`uid`) - ) - - CREATE TABLE `userdetail` ( - `uid` INT(10) NOT NULL DEFAULT '0', - `intro` TEXT NULL, - `profile` TEXT NULL, - PRIMARY KEY (`uid`) - ) - -如下示例将示范如何使用database/sql接口对数据库表进行增删改查操作 - -package main - - import ( - _ "code.google.com/p/go-mysql-driver/mysql" - "database/sql" - "fmt" - //"time" - ) - - func main() { - db, err := sql.Open("mysql", "astaxie:astaxie@/test?charset=utf8") - checkErr(err) - - //插入数据 - stmt, err := db.Prepare("INSERT userinfo SET username=?,departname=?,created=?") - checkErr(err) - - res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09") - checkErr(err) - - id, err := res.LastInsertId() - checkErr(err) - - fmt.Println(id) - //更新数据 - stmt, err = db.Prepare("update userinfo set username=? where uid=?") - checkErr(err) - - res, err = stmt.Exec("astaxieupdate", id) - checkErr(err) - - affect, err := res.RowsAffected() - checkErr(err) - - fmt.Println(affect) - - //查询数据 - rows, err := db.Query("SELECT * FROM userinfo") - checkErr(err) - - for rows.Next() { - var uid int - var username string - var department string - var created string - err = rows.Scan(&uid, &username, &department, &created) - checkErr(err) - fmt.Println(uid) - fmt.Println(username) - fmt.Println(department) - fmt.Println(created) - } - - //删除数据 - stmt, err = db.Prepare("delete from userinfo where uid=?") - checkErr(err) - - res, err = stmt.Exec(id) - checkErr(err) - - affect, err = res.RowsAffected() - checkErr(err) - - fmt.Println(affect) - - } - - func checkErr(err error) { - if err != nil { - panic(err) - } - } - - -通过上面的代码我们可以看出，Go操作Mysql数据库是很方便的。 - -关键的几个函数我解释一下： - -sql.Open()函数用来打开一个注册过的数据库驱动，go-mysql-driver中注册了mysql这个数据库驱动，第二个参数是DNS(Data Source Name)，它是go-mysql-drivev定义的一些数据库链接和配置信息。它支持如下格式： - - user@unix(/path/to/socket)/dbname?charset=utf8 - user:password@tcp(localhost:5555)/dbname?charset=utf8&keepalive=1 - user:password@/dbname - user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname - -db.Prepare()函数用来返回准备要执行的sql操作，然后返回准备完毕的执行状态。 - -db.Query()函数用来直接执行Sql返回Rows结果。 - -stmt.Exec()函数用来执行stmt准备好的SQL语句 - -我们可以看到我们传入的参数都是=?对应的数据，这样做的方式可以一定程度上防止SQL注入。 - - - -## links - * [目录]() - * 上一节: [database/sql接口](<5.1.md>) - * 下一节: [使用SQLite数据库](<5.3.md>) +# 5.2使用MySQL数据库 +目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。 + +## MySQL驱动 +Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: + +- http://code.google.com/p/go-mysql-driver/ 支持database/sql，全部采用go写。 +- https://github.com/ziutek/mymysql 支持database/sql，也支持自定义的接口，全部采用go写。 +- https://github.com/Philio/GoMySQL 不支持database/sql，自定义接口，全部采用go写。 + +接下来的例子我主要以第一个驱动为例(我目前项目中也是采用它来驱动)，也推荐大家采用它，主要理由： + +- 这个驱动比较新，维护的比较好 +- 完全支持database/sql接口 +- 支持keepalive，保持长连接,虽然[星星](http://www.mikespook.com)fork的mymysql也支持keepalive，但不是线程安全的，这个从底层就支持了keepalive。 + +## 示例代码 +接下来的几个小节里面我们都将采用同一个数据库表结构：数据库test，用户表userinfo，关联用户信息表userdetail。 + + CREATE TABLE `userinfo` ( + `uid` INT(10) NOT NULL AUTO_INCREMENT, + `username` VARCHAR(64) NULL DEFAULT NULL, + `departname` VARCHAR(64) NULL DEFAULT NULL, + `created` DATE NULL DEFAULT NULL, + PRIMARY KEY (`uid`) + ) + + CREATE TABLE `userdetail` ( + `uid` INT(10) NOT NULL DEFAULT '0', + `intro` TEXT NULL, + `profile` TEXT NULL, + PRIMARY KEY (`uid`) + ) + +如下示例将示范如何使用database/sql接口对数据库表进行增删改查操作 + + package main + + import ( + _ "code.google.com/p/go-mysql-driver/mysql" + "database/sql" + "fmt" + //"time" + ) + + func main() { + db, err := sql.Open("mysql", "astaxie:astaxie@/test?charset=utf8") + checkErr(err) + + //插入数据 + stmt, err := db.Prepare("INSERT userinfo SET username=?,departname=?,created=?") + checkErr(err) + + res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09") + checkErr(err) + + id, err := res.LastInsertId() + checkErr(err) + + fmt.Println(id) + //更新数据 + stmt, err = db.Prepare("update userinfo set username=? where uid=?") + checkErr(err) + + res, err = stmt.Exec("astaxieupdate", id) + checkErr(err) + + affect, err := res.RowsAffected() + checkErr(err) + + fmt.Println(affect) + + //查询数据 + rows, err := db.Query("SELECT * FROM userinfo") + checkErr(err) + + for rows.Next() { + var uid int + var username string + var department string + var created string + err = rows.Scan(&uid, &username, &department, &created) + checkErr(err) + fmt.Println(uid) + fmt.Println(username) + fmt.Println(department) + fmt.Println(created) + } + + //删除数据 + stmt, err = db.Prepare("delete from userinfo where uid=?") + checkErr(err) + + res, err = stmt.Exec(id) + checkErr(err) + + affect, err = res.RowsAffected() + checkErr(err) + + fmt.Println(affect) + + db.Close() + + } + + func checkErr(err error) { + if err != nil { + panic(err) + } + } + + +通过上面的代码我们可以看出，Go操作Mysql数据库是很方便的。 + +关键的几个函数我解释一下： + +sql.Open()函数用来打开一个注册过的数据库驱动，go-mysql-driver中注册了mysql这个数据库驱动，第二个参数是DNS(Data Source Name)，它是go-mysql-drivev定义的一些数据库链接和配置信息。它支持如下格式： + + user@unix(/path/to/socket)/dbname?charset=utf8 + user:password@tcp(localhost:5555)/dbname?charset=utf8&keepalive=1 + user:password@/dbname + user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname + +db.Prepare()函数用来返回准备要执行的sql操作，然后返回准备完毕的执行状态。 + +db.Query()函数用来直接执行Sql返回Rows结果。 + +stmt.Exec()函数用来执行stmt准备好的SQL语句 + +我们可以看到我们传入的参数都是=?对应的数据，这样做的方式可以一定程度上防止SQL注入。 + + + +## links + * [目录]() + * 上一节: [database/sql接口](<5.1.md>) + * 下一节: [使用SQLite数据库](<5.3.md>) diff --git a/5.3.md b/5.3.md index 5029aec7..c18e8455 100644 --- a/5.3.md +++ b/5.3.md @@ -1,116 +1,118 @@ -# 5.3使用SQLite数据库 - -SQLite 是一个开源的嵌入式关系数据库，实现自包容、零配置、支持事务的SQL数据库引擎。其特点是高度便携、使用方便、结构紧凑、高效、可靠。 与其他数据库管理系统不同，SQLite 的安装和运行非常简单，在大多数情况下,只要确保SQLite的二进制文件存在即可开始创建、连接和使用数据库。如果您正在寻找一个嵌入式数据库项目或解决方案，SQLite是绝对值得考虑。SQLite可以是说开源的Access。 - -## 驱动 -Go支持sqlite的驱动也比较多，但是好多都是不支持database/sql接口的 - -- https://github.com/mattn/go-sqlite3 支持database/sql接口，基于cgo(关于cgo的知识请参看官方文档或者本书后面的章节)写的 -- https://github.com/feyeleanor/gosqlite3 不支持database/sql接口，基于cgo写的 -- https://github.com/phf/go-sqlite3 不支持database/sql接口，基于cgo写的 - -目前支持database/sql的SQLite数据库驱动只有第一个，我目前也是采用它来开发项目的。采用标准接口有利于以后出现更好的驱动的时候做迁移。 - -## 实例代码 -示例的数据库表结构如下所示，相应的建表SQL： - - CREATE TABLE `userinfo` ( - `uid` INTEGER PRIMARY KEY AUTOINCREMENT, - `username` VARCHAR(64) NULL, - `departname` VARCHAR(64) NULL, - `created` DATE NULL - ); - - CREATE TABLE `userdeatail` ( - `uid` INT(10) NULL, - `intro` TEXT NULL, - `profile` TEXT NULL, - PRIMARY KEY (`uid`) - ); - -看下面Go程序是如何操作数据库表数据:增删改查 - - package main - - import ( - "database/sql" - "fmt" - _ "github.com/mattn/go-sqlite3" - ) - - func main() { - db, err := sql.Open("sqlite3", "./foo.db") - checkErr(err) - - //插入数据 - stmt, err := db.Prepare("INSERT INTO userinfo(username, departname, created) values(?,?,?)") - checkErr(err) - - res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09") - checkErr(err) - - id, err := res.LastInsertId() - checkErr(err) - - fmt.Println(id) - //更新数据 - stmt, err = db.Prepare("update userinfo set username=? where uid=?") - checkErr(err) - - res, err = stmt.Exec("astaxieupdate", id) - checkErr(err) - - affect, err := res.RowsAffected() - checkErr(err) - - fmt.Println(affect) - - //查询数据 - rows, err := db.Query("SELECT * FROM userinfo") - checkErr(err) - - for rows.Next() { - var uid int - var username string - var department string - var created string - err = rows.Scan(&uid, &username, &department, &created) - checkErr(err) - fmt.Println(uid) - fmt.Println(username) - fmt.Println(department) - fmt.Println(created) - } - - //删除数据 - stmt, err = db.Prepare("delete from userinfo where uid=?") - checkErr(err) - - res, err = stmt.Exec(id) - checkErr(err) - - affect, err = res.RowsAffected() - checkErr(err) - - fmt.Println(affect) - - } - - func checkErr(err error) { - if err != nil { - panic(err) - } - } - - -我们可以看到上面的代码和MySQL例子里面的代码几乎是一模一样的，唯一改变的就是导入的驱动改变了，然后调用`sql.Open`是采用了SQLite的方式打开。 - - ->sqlite管理工具：http://sqliteadmin.orbmu2k.de/ - ->可以方便的新建数据库管理。 - -## links - * [目录]() - * 上一节: [使用MySQL数据库](<5.2.md>) - * 下一节: [使用PostgreSQL数据库](<5.4.md>) +# 5.3使用SQLite数据库 + +SQLite 是一个开源的嵌入式关系数据库，实现自包容、零配置、支持事务的SQL数据库引擎。其特点是高度便携、使用方便、结构紧凑、高效、可靠。 与其他数据库管理系统不同，SQLite 的安装和运行非常简单，在大多数情况下,只要确保SQLite的二进制文件存在即可开始创建、连接和使用数据库。如果您正在寻找一个嵌入式数据库项目或解决方案，SQLite是绝对值得考虑。SQLite可以是说开源的Access。 + +## 驱动 +Go支持sqlite的驱动也比较多，但是好多都是不支持database/sql接口的 + +- https://github.com/mattn/go-sqlite3 支持database/sql接口，基于cgo(关于cgo的知识请参看官方文档或者本书后面的章节)写的 +- https://github.com/feyeleanor/gosqlite3 不支持database/sql接口，基于cgo写的 +- https://github.com/phf/go-sqlite3 不支持database/sql接口，基于cgo写的 + +目前支持database/sql的SQLite数据库驱动只有第一个，我目前也是采用它来开发项目的。采用标准接口有利于以后出现更好的驱动的时候做迁移。 + +## 实例代码 +示例的数据库表结构如下所示，相应的建表SQL： + + CREATE TABLE `userinfo` ( + `uid` INTEGER PRIMARY KEY AUTOINCREMENT, + `username` VARCHAR(64) NULL, + `departname` VARCHAR(64) NULL, + `created` DATE NULL + ); + + CREATE TABLE `userdeatail` ( + `uid` INT(10) NULL, + `intro` TEXT NULL, + `profile` TEXT NULL, + PRIMARY KEY (`uid`) + ); + +看下面Go程序是如何操作数据库表数据:增删改查 + + package main + + import ( + "database/sql" + "fmt" + _ "github.com/mattn/go-sqlite3" + ) + + func main() { + db, err := sql.Open("sqlite3", "./foo.db") + checkErr(err) + + //插入数据 + stmt, err := db.Prepare("INSERT INTO userinfo(username, departname, created) values(?,?,?)") + checkErr(err) + + res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09") + checkErr(err) + + id, err := res.LastInsertId() + checkErr(err) + + fmt.Println(id) + //更新数据 + stmt, err = db.Prepare("update userinfo set username=? where uid=?") + checkErr(err) + + res, err = stmt.Exec("astaxieupdate", id) + checkErr(err) + + affect, err := res.RowsAffected() + checkErr(err) + + fmt.Println(affect) + + //查询数据 + rows, err := db.Query("SELECT * FROM userinfo") + checkErr(err) + + for rows.Next() { + var uid int + var username string + var department string + var created string + err = rows.Scan(&uid, &username, &department, &created) + checkErr(err) + fmt.Println(uid) + fmt.Println(username) + fmt.Println(department) + fmt.Println(created) + } + + //删除数据 + stmt, err = db.Prepare("delete from userinfo where uid=?") + checkErr(err) + + res, err = stmt.Exec(id) + checkErr(err) + + affect, err = res.RowsAffected() + checkErr(err) + + fmt.Println(affect) + + db.Close() + + } + + func checkErr(err error) { + if err != nil { + panic(err) + } + } + + +我们可以看到上面的代码和MySQL例子里面的代码几乎是一模一样的，唯一改变的就是导入的驱动改变了，然后调用`sql.Open`是采用了SQLite的方式打开。 + + +>sqlite管理工具：http://sqliteadmin.orbmu2k.de/ + +>可以方便的新建数据库管理。 + +## links + * [目录]() + * 上一节: [使用MySQL数据库](<5.2.md>) + * 下一节: [使用PostgreSQL数据库](<5.4.md>) diff --git a/5.4.md b/5.4.md index bf0980bb..0e48b539 100644 --- a/5.4.md +++ b/5.4.md @@ -1,122 +1,124 @@ -# 5.4使用PostgreSQL数据库 - -PostgreSQL 是一个自由的对象-关系数据库服务器(数据库管理系统)，它在灵活的 BSD-风格许可证下发行。它提供了相对其他开放源代码数据库系统(比如 MySQL 和 Firebird)，和对专有系统比如 Oracle、Sybase、IBM 的 DB2 和 Microsoft SQL Server的一种选择。 - -PostgreSQL和MySQL比较，它更加庞大一点，因为它是用来替代Oracle而设计的。所以在企业应用中采用PostgreSQL是一个明智的选择。 - -现在MySQL被Oracle收购之后，有传闻Oracle正在逐步的封闭MySQL,,鉴于此，将来我们也许会选择PostgreSQL而不是MySQL作为项目的后端数据库。 - -## 驱动 -Go实现的支持PostgreSQL的驱动也很多，因为国外很多人在开发中使用了这个数据库。 - -- https://github.com/bmizerany/pq 支持database/sql驱动，纯Go写的 -- https://github.com/jbarham/gopgsqldriver 支持database/sql驱动，纯Go写的 -- https://github.com/lxn/go-pgsql 支持database/sql驱动，纯Go写的 - -在下面的示例中我采用了第一个驱动，因为它目前使用的人最多，在github上也比较活跃。 - -## 实例代码 -数据库建表语句： - - CREATE TABLE userinfo - ( - uid serial NOT NULL, - username character varying(100) NOT NULL, - departname character varying(500) NOT NULL, - Created date, - CONSTRAINT userinfo_pkey PRIMARY KEY (uid) - ) - WITH (OIDS=FALSE); - - CREATE TABLE userdeatail - ( - uid integer, - intro character varying(100), - profile character varying(100) - ) - WITH(OIDS=FALSE); - -看下面这个Go如何操作数据库表数据:增删改查 - -package main - - import ( - "database/sql" - "fmt" - _ "github.com/bmizerany/pq" - ) - - func main() { - db, err := sql.Open("postgres", "user=astaxie password=astaxie dbname=test sslmode=disable") - checkErr(err) - - //插入数据 - stmt, err := db.Prepare("INSERT INTO userinfo(username,departname,created) VALUES($1,$2,$3) RETURNING uid") - checkErr(err) - - res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09") - checkErr(err) - - //pg不支持这个函数，因为他没有类似MySQL的自增ID - id, err := res.LastInsertId() - checkErr(err) - - fmt.Println(id) - - //更新数据 - stmt, err = db.Prepare("update userinfo set username=$1 where uid=$2") - checkErr(err) - - res, err = stmt.Exec("astaxieupdate", 1) - checkErr(err) - - affect, err := res.RowsAffected() - checkErr(err) - - fmt.Println(affect) - - //查询数据 - rows, err := db.Query("SELECT * FROM userinfo") - checkErr(err) - - for rows.Next() { - var uid int - var username string - var department string - var created string - err = rows.Scan(&uid, &username, &department, &created) - checkErr(err) - fmt.Println(uid) - fmt.Println(username) - fmt.Println(department) - fmt.Println(created) - } - - //删除数据 - stmt, err = db.Prepare("delete from userinfo where uid=$1") - checkErr(err) - - res, err = stmt.Exec(1) - checkErr(err) - - affect, err = res.RowsAffected() - checkErr(err) - - fmt.Println(affect) - - } - - func checkErr(err error) { - if err != nil { - panic(err) - } - } - -从上面的代码我们可以看到，PostgreSQL是通过`$1`,`$2`这种方式来指定要传递的参数，而不是MySQL中的`?`，另外在sql.Open中的dsn信息的格式也与MySQL的驱动中的dsn格式不一样，所以在使用时请注意它们的差异。 - -还有pg不支持LastInsertId函数，因为PostgreSQL内部没有实现类似MySQL的自增ID返回，其他的代码几乎是一模一样。 - -## links - * [目录]() - * 上一节: [使用SQLite数据库](<5.3.md>) - * 下一节: [使用beedb库进行ORM开发](<5.5.md>) +# 5.4使用PostgreSQL数据库 + +PostgreSQL 是一个自由的对象-关系数据库服务器(数据库管理系统)，它在灵活的 BSD-风格许可证下发行。它提供了相对其他开放源代码数据库系统(比如 MySQL 和 Firebird)，和对专有系统比如 Oracle、Sybase、IBM 的 DB2 和 Microsoft SQL Server的一种选择。 + +PostgreSQL和MySQL比较，它更加庞大一点，因为它是用来替代Oracle而设计的。所以在企业应用中采用PostgreSQL是一个明智的选择。 + +现在MySQL被Oracle收购之后，有传闻Oracle正在逐步的封闭MySQL,,鉴于此，将来我们也许会选择PostgreSQL而不是MySQL作为项目的后端数据库。 + +## 驱动 +Go实现的支持PostgreSQL的驱动也很多，因为国外很多人在开发中使用了这个数据库。 + +- https://github.com/bmizerany/pq 支持database/sql驱动，纯Go写的 +- https://github.com/jbarham/gopgsqldriver 支持database/sql驱动，纯Go写的 +- https://github.com/lxn/go-pgsql 支持database/sql驱动，纯Go写的 + +在下面的示例中我采用了第一个驱动，因为它目前使用的人最多，在github上也比较活跃。 + +## 实例代码 +数据库建表语句： + + CREATE TABLE userinfo + ( + uid serial NOT NULL, + username character varying(100) NOT NULL, + departname character varying(500) NOT NULL, + Created date, + CONSTRAINT userinfo_pkey PRIMARY KEY (uid) + ) + WITH (OIDS=FALSE); + + CREATE TABLE userdeatail + ( + uid integer, + intro character varying(100), + profile character varying(100) + ) + WITH(OIDS=FALSE); + +看下面这个Go如何操作数据库表数据:增删改查 + +package main + + import ( + "database/sql" + "fmt" + _ "github.com/bmizerany/pq" + ) + + func main() { + db, err := sql.Open("postgres", "user=astaxie password=astaxie dbname=test sslmode=disable") + checkErr(err) + + //插入数据 + stmt, err := db.Prepare("INSERT INTO userinfo(username,departname,created) VALUES($1,$2,$3) RETURNING uid") + checkErr(err) + + res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09") + checkErr(err) + + //pg不支持这个函数，因为他没有类似MySQL的自增ID + id, err := res.LastInsertId() + checkErr(err) + + fmt.Println(id) + + //更新数据 + stmt, err = db.Prepare("update userinfo set username=$1 where uid=$2") + checkErr(err) + + res, err = stmt.Exec("astaxieupdate", 1) + checkErr(err) + + affect, err := res.RowsAffected() + checkErr(err) + + fmt.Println(affect) + + //查询数据 + rows, err := db.Query("SELECT * FROM userinfo") + checkErr(err) + + for rows.Next() { + var uid int + var username string + var department string + var created string + err = rows.Scan(&uid, &username, &department, &created) + checkErr(err) + fmt.Println(uid) + fmt.Println(username) + fmt.Println(department) + fmt.Println(created) + } + + //删除数据 + stmt, err = db.Prepare("delete from userinfo where uid=$1") + checkErr(err) + + res, err = stmt.Exec(1) + checkErr(err) + + affect, err = res.RowsAffected() + checkErr(err) + + fmt.Println(affect) + + db.Close() + + } + + func checkErr(err error) { + if err != nil { + panic(err) + } + } + +从上面的代码我们可以看到，PostgreSQL是通过`$1`,`$2`这种方式来指定要传递的参数，而不是MySQL中的`?`，另外在sql.Open中的dsn信息的格式也与MySQL的驱动中的dsn格式不一样，所以在使用时请注意它们的差异。 + +还有pg不支持LastInsertId函数，因为PostgreSQL内部没有实现类似MySQL的自增ID返回，其他的代码几乎是一模一样。 + +## links + * [目录]() + * 上一节: [使用SQLite数据库](<5.3.md>) + * 下一节: [使用beedb库进行ORM开发](<5.5.md>) diff --git a/6.1.md b/6.1.md index 439f55e5..7b04f056 100644 --- a/6.1.md +++ b/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) diff --git a/7.1.md b/7.1.md index ca7096fd..4ccb6e0c 100644 --- a/7.1.md +++ b/7.1.md @@ -1,221 +1,221 @@ -# 7.1 XML处理 -XML作为一种数据交换和信息传递的格式已经十分普及。而随着Web服务日益广泛的应用，现在XML在日常的开发工作中也扮演了愈发重要的角色。这一小节， 我们将就Go语言标准包中的XML相关处理的包进行介绍。 - -这个小节不会涉及XML规范相关的内容（如需了解相关知识请参考其他文献），而是介绍如何用Go语言来编解码XML文件相关的知识。 - -假如你是一名运维人员，你为你所管理的所有服务器生成了如下内容的xml的配置文件： - - - - - Shanghai_VPN - 127.0.0.1 - - - Beijing_VPN - 127.0.0.2 - - - -上面的XML文档描述了两个服务器的信息，包含了服务器名和服务器的IP信息，接下来的Go例子以此XML描述的信息进行操作。 - -## 解析XML -如何解析如上这个XML文件喃呢？ 我们可以通过xml包的`Unmarshal`函数来达到我们的目的 - - func Unmarshal(data []byte, v interface{}) error - -data接收的是XML数据流，v是需要输出的结构，定义为interface，也就是可以把XML转换为任意的格式。我们这里主要介绍struct的转换，因为struct和XML都有类似树结构的特征。 - -示例代码如下： - - package main - - import ( - "encoding/xml" - "fmt" - "io/ioutil" - "os" - ) - - type Recurlyservers struct { - XMLName xml.Name `xml:"servers"` - Version string `xml:"version,attr"` - Svs []server `xml:"server"` - Description string `xml:",innerxml"` - } - - type server struct { - XMLName xml.Name `xml:"server"` - ServerName string `xml:"serverName"` - ServerIP string `xml:"serverIP"` - } - - func main() { - file, err := os.Open("servers.xml") // For read access. - defer file.Close() - if err != nil { - fmt.Printf("error: %v", err) - return - } - data, err := ioutil.ReadAll(file) - if err != nil { - fmt.Printf("error: %v", err) - return - } - v := Recurlyservers{} - err = xml.Unmarshal(data, &v) - if err != nil { - fmt.Printf("error: %v", err) - return - } - - fmt.Println(v) - } - - -XML本质上是一种树形的数据格式，而我们可以定义与之匹配的go 语言的 struct类型，然后通过xml.Unmarshal来将xml中的数据解析成对应的struct对象。如上例子输出如下数据 - - {{ servers} 1 [{{ server} Shanghai_VPN 127.0.0.1} {{ server} Beijing_VPN 127.0.0.2}] - - Shanghai_VPN - 127.0.0.1 - - - Beijing_VPN - 127.0.0.2 - - } - - -上面的例子中，将xml文件解析成对应的strcut对象是通过`xml.Unmarshal`来完成的，这个过程是如何实现的？可以看到我们的struct定义后面多了一些类似于`xml:"serverName"`这样的内容,这个是strcut的一个特性，它们被称为 strcut tag，它们是用来辅助反射的。我们来看一下`Unmarshal`的定义： - - func Unmarshal(data []byte, v interface{}) error - -我们看到函数定义了两个参数，第一个是XML数据流，第二个是存储的对应类型，目前支持struct、slice和string，XML包内部采用了反射来进行数据的映射，所以v里面的字段必须是导出的。`Unmarshal`解析的时候XML元素和字段怎么对应起来的呢？这是有一个优先级读取流程的，首先会读取struct tag，如果没有，那么就会对应字段名。必须注意一点的是解析的时候tag、字段名、XML元素都是大小写敏感的，所以必须一一对应字段。 - -Go语言的反射机制，可以利用这些tag信息来将来自XML文件中的数据反射成对应的struct对象，关于反射如何利用struct tag的更多内容请参阅reflect中的相关内容。 - -解析XML到struct的时候遵循如下的规则： - -- 如果struct的一个字段是string或者[]byte类型且它的tag含有`",innerxml"`，Unmarshal将会将此字段所对应的元素内所有内嵌的原始xml累加到此字段上，如上面例子Description定义。最后的输出是 - - - Shanghai_VPN - 127.0.0.1 - - - Beijing_VPN - 127.0.0.2 - - -- 如果struct中有一个叫做XMLName，且类型为xml.Name字段，那么在解析的时候就会保存这个element的名字到该字段,如上面例子中的servers。 -- 如果某个struct字段的tag定义中含有XML结构中element的名称，那么解析的时候就会把相应的element值赋值给该字段，如上servername和serverip定义。 -- 如果某个struct字段的tag定义了中含有`",attr"`，那么解析的时候就会将该结构所对应的element的与字段同名的属性的值赋值给该字段，如上version定义。 -- 如果某个struct字段的tag定义 型如`"a>b>c"`,则解析的时候，会将xml结构a下面的b下面的c元素的值赋值给该字段。 -- 如果某个struct字段的tag定义了`"-"`,那么不会为该字段解析匹配任何xml数据。 -- 如果struct字段后面的tag定义了`",any"`，如果他的子元素在不满足其他的规则的时候就会匹配到这个字段。 -- 如果某个XML元素包含一条或者多条注释，那么这些注释将被累加到第一个tag含有",comments"的字段上，这个字段的类型可能是[]byte或string,如果没有这样的字段存在，那么注释将会被抛弃。 - -上面详细讲述了如何定义struct的tag。 只要设置对了tag，那么XML解析就如上面示例般简单，tag和XML的element是一一对应的关系，如上所示，我们还可以通过slice来表示多个同级元素。 - ->注意： 为了正确解析，go语言的xml包要求struct定义中的所有字段必须是可导出的（即首字母大写） - -## 输出XML -假若我们不是要解析如上所示的XML文件，而是生成它，那么在go语言中又该如何实现呢？ xml包中提供了`Marshal`和`MarshalIndent`两个函数，来满足我们的需求。这两个函数主要的区别是第二个函数会增加前缀和缩进，函数的定义如下所示： - - func Marshal(v interface{}) ([]byte, error) - func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) - -两个函数第一个参数是用来生成XML的结构定义类型数据，都是返回生成的XML数据流。 - -下面我们来看一下如何输出如上的XML： - - package main - - import ( - "encoding/xml" - "fmt" - "os" - ) - - type Servers struct { - XMLName xml.Name `xml:"servers"` - Version string `xml:"version,attr"` - Svs []server `xml:"server"` - } - - type server struct { - ServerName string `xml:"serverName"` - ServerIP string `xml:"serverIP"` - } - - func main() { - v := &Servers{Version: "1"} - v.Svs = append(v.Svs, server{"Shanghai_VPN", "127.0.0.1"}) - v.Svs = append(v.Svs, server{"Beijing_VPN", "127.0.0.2"}) - output, err := xml.MarshalIndent(v, " ", " ") - if err != nil { - fmt.Printf("error: %v\n", err) - } - os.Stdout.Write([]byte(xml.Header)) - - os.Stdout.Write(output) - } -上面的代码输出如下信息： - - - - - Shanghai_VPN - 127.0.0.1 - - - Beijing_VPN - 127.0.0.2 - - - -和我们之前定义的文件的格式一模一样，之所以会有`os.Stdout.Write([]byte(xml.Header))` 这句代码的出现，是因为`xml.MarshalIndent`或者`xml.Marshal`输出的信息都是不带XML头的，为了生成正确的xml文件，我们使用了xml包预定义的Header变量。 - -我们看到`Marshal`函数接收的参数v是interface{}类型的，即它可以接受任意类型的参数，那么xml包，根据什么规则来生成相应的XML文件呢？ - -- 如果v是 array或者slice，那么输出每一个元素，类似value -- 如果v是指针，那么会Marshal指针指向的内容，如果指针为空，什么都不输出 -- 如果v是interface，那么就处理interface所包含的数据 -- 如果v是其他数据类型，就会输出这个数据类型所拥有的字段信息 - -生成的XML文件中的element的名字又是根据什么决定的呢？元素名按照如下优先级从struct中获取： - -- 如果v是struct，XMLName的tag中定义的名称 -- 类型为xml.Name的名叫XMLName的字段的值 -- 通过strcut中字段的tag来获取 -- 通过strcut的字段名用来获取 -- marshall的类型名称 - -我们应如何设置struct 中字段的tag信息以控制最终xml文件的生成呢？ - -- XMLName不会被输出 -- tag中含有`"-"`的字段不会输出 -- tag中含有`"name,attr"`，会以name作为属性名，字段值作为值输出为这个XML元素的属性，如上version字段所描述 -- tag中含有`",attr"`，会以这个struct的字段名作为属性名输出为XML元素的属性，类似上一条，只是这个name默认是字段名了。 -- tag中含有`",chardata"`，输出为xml的 character data而非element。 -- tag中含有`",innerxml"`，将会被原样输出，而不会进行常规的编码过程 -- tag中含有`",comment"`，将被当作xml注释来输出，而不会进行常规的编码过程，字段值中不能含有"--"字符串 -- tag中含有`"omitempty"`,如果该字段的值为空值那么该字段就不会被输出到XML，空值包括：false、0、nil指针或nil接口，任何长度为0的array, slice, map或者string -- tag中含有`"a>b>c"`，那么就会循环输出三个元素a包含b，b包含c，例如如下代码就会输出 - - FirstName string `xml:"name>first"` - LastName string `xml:"name>last"` - - - Asta - Xie - - - -上面我们介绍了如何使用Go语言的xml包来编/解码XML文件，重要的一点是对XML的所有操作都是通过struct tag来实现的，所以学会对struct tag的运用变得非常重要，在文章中我们简要的列举了如何定义tag。更多内容或tag定义请参看相应的官方资料。 - -## links - * [目录]() - * 上一节: [文本处理](<7.md>) - * 下一节: [Json处理](<7.2.md>) +# 7.1 XML处理 +XML作为一种数据交换和信息传递的格式已经十分普及。而随着Web服务日益广泛的应用，现在XML在日常的开发工作中也扮演了愈发重要的角色。这一小节， 我们将就Go语言标准包中的XML相关处理的包进行介绍。 + +这个小节不会涉及XML规范相关的内容（如需了解相关知识请参考其他文献），而是介绍如何用Go语言来编解码XML文件相关的知识。 + +假如你是一名运维人员，你为你所管理的所有服务器生成了如下内容的xml的配置文件： + + + + + Shanghai_VPN + 127.0.0.1 + + + Beijing_VPN + 127.0.0.2 + + + +上面的XML文档描述了两个服务器的信息，包含了服务器名和服务器的IP信息，接下来的Go例子以此XML描述的信息进行操作。 + +## 解析XML +如何解析如上这个XML文件喃呢？ 我们可以通过xml包的`Unmarshal`函数来达到我们的目的 + + func Unmarshal(data []byte, v interface{}) error + +data接收的是XML数据流，v是需要输出的结构，定义为interface，也就是可以把XML转换为任意的格式。我们这里主要介绍struct的转换，因为struct和XML都有类似树结构的特征。 + +示例代码如下： + + package main + + import ( + "encoding/xml" + "fmt" + "io/ioutil" + "os" + ) + + type Recurlyservers struct { + XMLName xml.Name `xml:"servers"` + Version string `xml:"version,attr"` + Svs []server `xml:"server"` + Description string `xml:",innerxml"` + } + + type server struct { + XMLName xml.Name `xml:"server"` + ServerName string `xml:"serverName"` + ServerIP string `xml:"serverIP"` + } + + func main() { + file, err := os.Open("servers.xml") // For read access. + 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) + return + } + v := Recurlyservers{} + err = xml.Unmarshal(data, &v) + if err != nil { + fmt.Printf("error: %v", err) + return + } + + fmt.Println(v) + } + + +XML本质上是一种树形的数据格式，而我们可以定义与之匹配的go 语言的 struct类型，然后通过xml.Unmarshal来将xml中的数据解析成对应的struct对象。如上例子输出如下数据 + + {{ servers} 1 [{{ server} Shanghai_VPN 127.0.0.1} {{ server} Beijing_VPN 127.0.0.2}] + + Shanghai_VPN + 127.0.0.1 + + + Beijing_VPN + 127.0.0.2 + + } + + +上面的例子中，将xml文件解析成对应的strcut对象是通过`xml.Unmarshal`来完成的，这个过程是如何实现的？可以看到我们的struct定义后面多了一些类似于`xml:"serverName"`这样的内容,这个是strcut的一个特性，它们被称为 strcut tag，它们是用来辅助反射的。我们来看一下`Unmarshal`的定义： + + func Unmarshal(data []byte, v interface{}) error + +我们看到函数定义了两个参数，第一个是XML数据流，第二个是存储的对应类型，目前支持struct、slice和string，XML包内部采用了反射来进行数据的映射，所以v里面的字段必须是导出的。`Unmarshal`解析的时候XML元素和字段怎么对应起来的呢？这是有一个优先级读取流程的，首先会读取struct tag，如果没有，那么就会对应字段名。必须注意一点的是解析的时候tag、字段名、XML元素都是大小写敏感的，所以必须一一对应字段。 + +Go语言的反射机制，可以利用这些tag信息来将来自XML文件中的数据反射成对应的struct对象，关于反射如何利用struct tag的更多内容请参阅reflect中的相关内容。 + +解析XML到struct的时候遵循如下的规则： + +- 如果struct的一个字段是string或者[]byte类型且它的tag含有`",innerxml"`，Unmarshal将会将此字段所对应的元素内所有内嵌的原始xml累加到此字段上，如上面例子Description定义。最后的输出是 + + + Shanghai_VPN + 127.0.0.1 + + + Beijing_VPN + 127.0.0.2 + + +- 如果struct中有一个叫做XMLName，且类型为xml.Name字段，那么在解析的时候就会保存这个element的名字到该字段,如上面例子中的servers。 +- 如果某个struct字段的tag定义中含有XML结构中element的名称，那么解析的时候就会把相应的element值赋值给该字段，如上servername和serverip定义。 +- 如果某个struct字段的tag定义了中含有`",attr"`，那么解析的时候就会将该结构所对应的element的与字段同名的属性的值赋值给该字段，如上version定义。 +- 如果某个struct字段的tag定义 型如`"a>b>c"`,则解析的时候，会将xml结构a下面的b下面的c元素的值赋值给该字段。 +- 如果某个struct字段的tag定义了`"-"`,那么不会为该字段解析匹配任何xml数据。 +- 如果struct字段后面的tag定义了`",any"`，如果他的子元素在不满足其他的规则的时候就会匹配到这个字段。 +- 如果某个XML元素包含一条或者多条注释，那么这些注释将被累加到第一个tag含有",comments"的字段上，这个字段的类型可能是[]byte或string,如果没有这样的字段存在，那么注释将会被抛弃。 + +上面详细讲述了如何定义struct的tag。 只要设置对了tag，那么XML解析就如上面示例般简单，tag和XML的element是一一对应的关系，如上所示，我们还可以通过slice来表示多个同级元素。 + +>注意： 为了正确解析，go语言的xml包要求struct定义中的所有字段必须是可导出的（即首字母大写） + +## 输出XML +假若我们不是要解析如上所示的XML文件，而是生成它，那么在go语言中又该如何实现呢？ xml包中提供了`Marshal`和`MarshalIndent`两个函数，来满足我们的需求。这两个函数主要的区别是第二个函数会增加前缀和缩进，函数的定义如下所示： + + func Marshal(v interface{}) ([]byte, error) + func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) + +两个函数第一个参数是用来生成XML的结构定义类型数据，都是返回生成的XML数据流。 + +下面我们来看一下如何输出如上的XML： + + package main + + import ( + "encoding/xml" + "fmt" + "os" + ) + + type Servers struct { + XMLName xml.Name `xml:"servers"` + Version string `xml:"version,attr"` + Svs []server `xml:"server"` + } + + type server struct { + ServerName string `xml:"serverName"` + ServerIP string `xml:"serverIP"` + } + + func main() { + v := &Servers{Version: "1"} + v.Svs = append(v.Svs, server{"Shanghai_VPN", "127.0.0.1"}) + v.Svs = append(v.Svs, server{"Beijing_VPN", "127.0.0.2"}) + output, err := xml.MarshalIndent(v, " ", " ") + if err != nil { + fmt.Printf("error: %v\n", err) + } + os.Stdout.Write([]byte(xml.Header)) + + os.Stdout.Write(output) + } +上面的代码输出如下信息： + + + + + Shanghai_VPN + 127.0.0.1 + + + Beijing_VPN + 127.0.0.2 + + + +和我们之前定义的文件的格式一模一样，之所以会有`os.Stdout.Write([]byte(xml.Header))` 这句代码的出现，是因为`xml.MarshalIndent`或者`xml.Marshal`输出的信息都是不带XML头的，为了生成正确的xml文件，我们使用了xml包预定义的Header变量。 + +我们看到`Marshal`函数接收的参数v是interface{}类型的，即它可以接受任意类型的参数，那么xml包，根据什么规则来生成相应的XML文件呢？ + +- 如果v是 array或者slice，那么输出每一个元素，类似value +- 如果v是指针，那么会Marshal指针指向的内容，如果指针为空，什么都不输出 +- 如果v是interface，那么就处理interface所包含的数据 +- 如果v是其他数据类型，就会输出这个数据类型所拥有的字段信息 + +生成的XML文件中的element的名字又是根据什么决定的呢？元素名按照如下优先级从struct中获取： + +- 如果v是struct，XMLName的tag中定义的名称 +- 类型为xml.Name的名叫XMLName的字段的值 +- 通过strcut中字段的tag来获取 +- 通过strcut的字段名用来获取 +- marshall的类型名称 + +我们应如何设置struct 中字段的tag信息以控制最终xml文件的生成呢？ + +- XMLName不会被输出 +- tag中含有`"-"`的字段不会输出 +- tag中含有`"name,attr"`，会以name作为属性名，字段值作为值输出为这个XML元素的属性，如上version字段所描述 +- tag中含有`",attr"`，会以这个struct的字段名作为属性名输出为XML元素的属性，类似上一条，只是这个name默认是字段名了。 +- tag中含有`",chardata"`，输出为xml的 character data而非element。 +- tag中含有`",innerxml"`，将会被原样输出，而不会进行常规的编码过程 +- tag中含有`",comment"`，将被当作xml注释来输出，而不会进行常规的编码过程，字段值中不能含有"--"字符串 +- tag中含有`"omitempty"`,如果该字段的值为空值那么该字段就不会被输出到XML，空值包括：false、0、nil指针或nil接口，任何长度为0的array, slice, map或者string +- tag中含有`"a>b>c"`，那么就会循环输出三个元素a包含b，b包含c，例如如下代码就会输出 + + FirstName string `xml:"name>first"` + LastName string `xml:"name>last"` + + + Asta + Xie + + + +上面我们介绍了如何使用Go语言的xml包来编/解码XML文件，重要的一点是对XML的所有操作都是通过struct tag来实现的，所以学会对struct tag的运用变得非常重要，在文章中我们简要的列举了如何定义tag。更多内容或tag定义请参看相应的官方资料。 + +## links + * [目录]() + * 上一节: [文本处理](<7.md>) + * 下一节: [Json处理](<7.2.md>) diff --git a/8.1.md b/8.1.md index f323aaa9..9c758d7e 100644 --- a/8.1.md +++ b/8.1.md @@ -1,326 +1,326 @@ -# 8.1 Socket编程 -在很多底层网络应用开发者的眼里一切编程都是Socket，话虽然有点夸张，但却也几乎如此了，现在的网络编程几乎都是用Socket来编程。你想过这些情景么？我们每天打开浏览器浏览网页时，浏览器进程怎么和Web服务器进行通信的呢？当你用QQ聊天时，QQ进程怎么和服务器或者是你的好友所在的QQ进程进行通信的呢？当你打开PPstream观看视频时，PPstream进程如何与视频服务器进行通信的呢？ 如此种种，都是靠Socket来进行通信的，以一斑窥全豹，可见Socket编程在现代编程中占据了多么重要的地位，这一节我们将介绍Go语言中如何进行Socket编程。 - -## 什么是Socket？ -Socket起源于Unix，而Unix基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现，网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用：Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。 - -常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。 -## Socket如何通信 -网络中的进程之间如何通过Socket通信呢？首要解决的问题是如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中需要互相通信的进程，就可以利用这个标志在他们之间进行交互。请看下面这个TCP/IP协议结构图 - -![](images/8.1.socket.png?raw=true) - -使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是为什么说“一切皆Socket”。 - -## Socket基础知识 -通过上面的介绍我们知道Socket有两种：TCP Socket和UDP Socket，TCP和UDP是协议，而要确定一个进程的需要三元组，需要IP地址和端口。 - -### IPv4地址 -目前的全球因特网所采用的协议族是TCP/IP协议。IP是TCP/IP协议中网络层的协议，是TCP/IP协议族的核心协议。目前主要采用的IP协议的版本号是4(简称为IPv4)，发展至今已经使用了30多年。 - -IPv4的地址位数为32位，也就是最多有2的32次方的网络设备可以联到Internet上。近十年来由于互联网的蓬勃发展，IP位址的需求量愈来愈大，使得IP位址的发放愈趋紧张，前一段时间，据报道IPV4的地址已经发放完毕，我们公司目前很多服务器的IP都是一个宝贵的资源。 - -地址格式类似这样：127.0.0.1 172.122.121.111 - -### IPv6地址 -IPv6是下一版本的互联网协议，也可以说是下一代互联网的协议，它是为了解决IPv4在实施过程中遇到的各种问题而被提出的，IPv6采用128位地址长度，几乎可以不受限制地提供地址。按保守方法估算IPv6实际可分配的地址，整个地球的每平方米面积上仍可分配1000多个地址。在IPv6的设计过程中除了一劳永逸地解决了地址短缺问题以外，还考虑了在IPv4中解决不好的其它问题，主要有端到端IP连接、服务质量（QoS）、安全性、多播、移动性、即插即用等。 - -地址格式类似这样：2002:c0e8:82e7:0:0:0:c0e8:82e7 - -### Go支持的IP类型 -在Go的`net`包中定义了很多类型、函数和方法用来网络编程，其中IP的定义如下： - - type IP []byte - -在`net`包中有很多函数来操作IP，但是其中比较有用的也就几个，其中`ParseIP(s string) IP`函数会把一个IPv4或者IPv6的地址转化成IP类型，请看下面的例子: - - package main - import ( - "net" - "os" - "fmt" - ) - func main() { - if len(os.Args) != 2 { - fmt.Fprintf(os.Stderr, "Usage: %s ip-addr\n", os.Args[0]) - os.Exit(1) - } - name := os.Args[1] - addr := net.ParseIP(name) - if addr == nil { - fmt.Println("Invalid address") - } else { - fmt.Println("The address is ", addr.String()) - } - os.Exit(0) - } - -执行之后你就会发现只要你输入一个IP地址就会给出相应的IP格式 - -## TCP Socket -当我们知道如何通过网络端口访问一个服务时，那么我们能够做什么呢？作为客户端来说，我们可以通过向远端某台机器的的某个网络端口发送一个请求，然后得到在机器的此端口上监听的服务反馈的信息。作为服务端，我们需要把服务绑定到某个指定端口，并且在此端口上监听，当有客户端来访问时能够读取信息并且写入反馈信息。 - -在Go语言的`net`包中有一个类型`TCPConn`，这个类型可以用来作为客户端和服务器端交互的通道，他有两个主要的函数： - - func (c *TCPConn) Write(b []byte) (n int, err os.Error) - func (c *TCPConn) Read(b []byte) (n int, err os.Error) - -`TCPConn`可以用在客户端和服务器端来读写数据。 - -还有我们需要知道一个`TCPAddr`类型，他表示一个TCP的地址信息，他的定义如下： - - type TCPAddr struct { - IP IP - Port int - } -在Go语言中通过`ResolveTCPAddr`获取一个`TCPAddr` - - func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error) - -- net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only),TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个). -- addr表示域名或者IP地址，例如"www.google.com:80" 或者"127.0.0.1:22". - - -### TCP client -Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回一个`TCPConn`类型的对象，当连接建立时服务器端也创建一个同类型的对象，此时客户端和服务器段通过各自拥有的`TCPConn`对象来进行数据交换。一般而言，客户端通过`TCPConn`对象将请求信息发送到服务器端，读取服务器端响应的信息。服务器端读取并解析来自客户端的请求，并返回应答信息，这个连接只有当任一端关闭了连接之后才失效，不然这连接可以一直在使用。建立连接的函数定义如下： - - func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err os.Error) - -- net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only)、TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个) -- laddr表示本机地址，一般设置为nil -- raddr表示远程的服务地址 - -接下来我们写一个简单的例子，模拟一个基于HTTP协议的客户端请求去连接一个Web服务端。我们要写一个简单的http请求头，格式类似如下： - - "HEAD / HTTP/1.0\r\n\r\n" - -从服务端接收到的响应信息格式可能如下： - - HTTP/1.0 200 OK - ETag: "-9985996" - Last-Modified: Thu, 25 Mar 2010 17:51:10 GMT - Content-Length: 18074 - Connection: close - Date: Sat, 28 Aug 2010 00:43:48 GMT - Server: lighttpd/1.4.23 - -我们的客户端代码如下所示： - - package main - - import ( - "fmt" - "io/ioutil" - "net" - "os" - ) - - func main() { - if len(os.Args) != 2 { - fmt.Fprintf(os.Stderr, "Usage: %s host:port ", os.Args[0]) - os.Exit(1) - } - service := os.Args[1] - tcpAddr, err := net.ResolveTCPAddr("tcp4", service) - checkError(err) - conn, err := net.DialTCP("tcp", nil, tcpAddr) - checkError(err) - _, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n")) - checkError(err) - result, err := ioutil.ReadAll(conn) - checkError(err) - fmt.Println(string(result)) - os.Exit(0) - } - func checkError(err error) { - if err != nil { - fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) - os.Exit(1) - } - } - -通过上面的代码我们可以看出：首先程序将用户的输入作为参数`service`传入`net.ResolveTCPAddr`获取一个tcpAddr,然后把tcpAddr传入DialTCP后创建了一个TCP连接`conn`，通过`conn`来发送请求信息，最后通过`ioutil.ReadAll`从`conn`中读取全部的文本，也就是服务端响应反馈的信息。 - -### TCP server -上面我们编写了一个TCP的客户端程序，也可以通过net包来创建一个服务器端程序，在服务器端我们需要绑定服务到指定的非激活端口，并监听此端口，当有客户端请求到达的时候可以接收到来自客户端连接的请求。net包中有相应功能的函数，函数定义如下： - - func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err os.Error) - func (l *TCPListener) Accept() (c Conn, err os.Error) - -参数说明同DialTCP的参数一样。下面我们实现一个简单的时间同步服务，监听7777端口 - - package main - - import ( - "fmt" - "net" - "os" - "time" - ) - - func main() { - service := ":7777" - tcpAddr, err := net.ResolveTCPAddr("ip4", service) - checkError(err) - listener, err := net.ListenTCP("tcp", tcpAddr) - checkError(err) - for { - conn, err := listener.Accept() - if err != nil { - continue - } - daytime := time.LocalTime().String() - conn.Write([]byte(daytime)) // don't care about return value - conn.Close() // we're finished with this client - } - } - func checkError(err error) { - if err != nil { - fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) - os.Exit(1) - } - } - -上面的服务跑起来之后，它将会一直在那里等待，直到有新的客户端请求到达。当有新的客户端请求到达并同意接受`Accept`该请求的时候他会反馈当前的时间信息。值得注意的是，在代码中`for`循环里，当有错误发生时，直接continue而不是退出，是因为在服务器端跑代码的时候，当有错误发生的情况下最好是由服务端记录错误，然后当前连接的客户端直接报错而退出，从而不会影响到当前服务端运行的整个服务。 - -上面的代码有个缺点，执行的时候是单任务的，不能同时接收多个请求，那么该如何改造以使它支持多并发呢？Go里面有一个goroutine机制，请看下面改造后的代码 - - package main - - import ( - "fmt" - "net" - "os" - "time" - ) - - func main() { - service := ":1200" - tcpAddr, err := net.ResolveTCPAddr("ip4", service) - checkError(err) - listener, err := net.ListenTCP("tcp", tcpAddr) - checkError(err) - for { - conn, err := listener.Accept() - if err != nil { - continue - } - go handlerClient(conn) - } - } - - func handleClient(conn net.Conn) { - defer conn.Close() - daytime := time.LocalTime().String() - conn.Write([]byte(daytime)) // don't care about return value - // we're finished with this client - } - func checkError(err error) { - if err != nil { - fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) - os.Exit(1) - } - } - -通过把业务处理分离到函数`handleClient`，我们就可以进一步地实现多并发执行了。看上去是不是很帅，增加`go`关键词就实现了服务端的多并发，从这个小例子也可以看出goroutine的强大之处。 - -### 控制TCP连接 -TCP有很多连接控制函数，我们平常用到比较多的有如下几个函数： - - func (c *TCPConn) SetTimeout(nsec int64) os.Error - func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error - -第一个函数用来设置连接的超时时间，客户端和服务器端都适用，当超过设置的时间时该连接就会失效。 - -第二个函数用来设置客户端是否和服务器端一直保持着连接，即使没有任何的数据发送。 - -更多的内容请查看`net`包的文档。 -## UDP Socket -Go语言包中处理UDP Socket和TCP Socket不同的地方就是在服务器端处理多个客户端请求数据包的方式不同,UDP缺少了对客户端连接请求的Accept函数。其他基本几乎一模一样，只有TCP换成了UDP而已。UDP的几个主要函数如下所示： - - func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error) - func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err os.Error) - func ListenUDP(net string, laddr *UDPAddr) (c *UDPConn, err os.Error) - func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error - func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error) - -一个UDP的客户端代码如下所示,我们可以看到不同的就是TCP换成了UDP而已： - - package main - - import ( - "fmt" - "net" - "os" - ) - - func main() { - if len(os.Args) != 2 { - fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0]) - os.Exit(1) - } - service := os.Args[1] - udpAddr, err := net.ResolveUDPAddr("udp4", service) - checkError(err) - conn, err := net.DialUDP("udp", nil, udpAddr) - checkError(err) - _, err = conn.Write([]byte("anything")) - checkError(err) - var buf [512]byte - n, err := conn.Read(buf[0:]) - checkError(err) - fmt.Println(string(buf[0:n])) - os.Exit(0) - } - func checkError(err error) { - if err != nil { - fmt.Fprintf(os.Stderr, "Fatal error ", err.Error()) - os.Exit(1) - } - } - -我们来看一下UDP服务器端如何来处理： - - package main - - import ( - "fmt" - "net" - "os" - "time" - ) - - func main() { - service := ":1200" - udpAddr, err := net.ResolveUDPAddr("udp4", service) - checkError(err) - conn, err := net.ListenUDP("udp", udpAddr) - checkError(err) - for { - handleClient(conn) - } - } - func handleClient(conn *net.UDPConn) { - var buf [512]byte - _, addr, err := conn.ReadFromUDP(buf[0:]) - if err != nil { - return - } - daytime := time.LocalTime().String() - conn.WriteToUDP([]byte(daytime), addr) - } - func checkError(err error) { - if err != nil { - fmt.Fprintf(os.Stderr, "Fatal error ", err.Error()) - os.Exit(1) - } - } - -## 总结 -通过对TCP和UDP Socket编程的描述和实现，可见Go已经完备地支持了Socket编程，而且使用起来相当的方便，Go提供了很多函数，通过这些函数可以很容易就编写出高性能的Socket应用。 - - -## links - * [目录]() - * 上一节: [Web服务](<8.md>) - * 下一节: [WebSocket](<8.2.md>) +# 8.1 Socket编程 +在很多底层网络应用开发者的眼里一切编程都是Socket，话虽然有点夸张，但却也几乎如此了，现在的网络编程几乎都是用Socket来编程。你想过这些情景么？我们每天打开浏览器浏览网页时，浏览器进程怎么和Web服务器进行通信的呢？当你用QQ聊天时，QQ进程怎么和服务器或者是你的好友所在的QQ进程进行通信的呢？当你打开PPstream观看视频时，PPstream进程如何与视频服务器进行通信的呢？ 如此种种，都是靠Socket来进行通信的，以一斑窥全豹，可见Socket编程在现代编程中占据了多么重要的地位，这一节我们将介绍Go语言中如何进行Socket编程。 + +## 什么是Socket？ +Socket起源于Unix，而Unix基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现，网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用：Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。 + +常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。 +## Socket如何通信 +网络中的进程之间如何通过Socket通信呢？首要解决的问题是如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中需要互相通信的进程，就可以利用这个标志在他们之间进行交互。请看下面这个TCP/IP协议结构图 + +![](images/8.1.socket.png?raw=true) + +使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是为什么说“一切皆Socket”。 + +## Socket基础知识 +通过上面的介绍我们知道Socket有两种：TCP Socket和UDP Socket，TCP和UDP是协议，而要确定一个进程的需要三元组，需要IP地址和端口。 + +### IPv4地址 +目前的全球因特网所采用的协议族是TCP/IP协议。IP是TCP/IP协议中网络层的协议，是TCP/IP协议族的核心协议。目前主要采用的IP协议的版本号是4(简称为IPv4)，发展至今已经使用了30多年。 + +IPv4的地址位数为32位，也就是最多有2的32次方的网络设备可以联到Internet上。近十年来由于互联网的蓬勃发展，IP位址的需求量愈来愈大，使得IP位址的发放愈趋紧张，前一段时间，据报道IPV4的地址已经发放完毕，我们公司目前很多服务器的IP都是一个宝贵的资源。 + +地址格式类似这样：127.0.0.1 172.122.121.111 + +### IPv6地址 +IPv6是下一版本的互联网协议，也可以说是下一代互联网的协议，它是为了解决IPv4在实施过程中遇到的各种问题而被提出的，IPv6采用128位地址长度，几乎可以不受限制地提供地址。按保守方法估算IPv6实际可分配的地址，整个地球的每平方米面积上仍可分配1000多个地址。在IPv6的设计过程中除了一劳永逸地解决了地址短缺问题以外，还考虑了在IPv4中解决不好的其它问题，主要有端到端IP连接、服务质量（QoS）、安全性、多播、移动性、即插即用等。 + +地址格式类似这样：2002:c0e8:82e7:0:0:0:c0e8:82e7 + +### Go支持的IP类型 +在Go的`net`包中定义了很多类型、函数和方法用来网络编程，其中IP的定义如下： + + type IP []byte + +在`net`包中有很多函数来操作IP，但是其中比较有用的也就几个，其中`ParseIP(s string) IP`函数会把一个IPv4或者IPv6的地址转化成IP类型，请看下面的例子: + + package main + import ( + "net" + "os" + "fmt" + ) + func main() { + if len(os.Args) != 2 { + fmt.Fprintf(os.Stderr, "Usage: %s ip-addr\n", os.Args[0]) + os.Exit(1) + } + name := os.Args[1] + addr := net.ParseIP(name) + if addr == nil { + fmt.Println("Invalid address") + } else { + fmt.Println("The address is ", addr.String()) + } + os.Exit(0) + } + +执行之后你就会发现只要你输入一个IP地址就会给出相应的IP格式 + +## TCP Socket +当我们知道如何通过网络端口访问一个服务时，那么我们能够做什么呢？作为客户端来说，我们可以通过向远端某台机器的的某个网络端口发送一个请求，然后得到在机器的此端口上监听的服务反馈的信息。作为服务端，我们需要把服务绑定到某个指定端口，并且在此端口上监听，当有客户端来访问时能够读取信息并且写入反馈信息。 + +在Go语言的`net`包中有一个类型`TCPConn`，这个类型可以用来作为客户端和服务器端交互的通道，他有两个主要的函数： + + func (c *TCPConn) Write(b []byte) (n int, err os.Error) + func (c *TCPConn) Read(b []byte) (n int, err os.Error) + +`TCPConn`可以用在客户端和服务器端来读写数据。 + +还有我们需要知道一个`TCPAddr`类型，他表示一个TCP的地址信息，他的定义如下： + + type TCPAddr struct { + IP IP + Port int + } +在Go语言中通过`ResolveTCPAddr`获取一个`TCPAddr` + + func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error) + +- net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only),TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个). +- addr表示域名或者IP地址，例如"www.google.com:80" 或者"127.0.0.1:22". + + +### TCP client +Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回一个`TCPConn`类型的对象，当连接建立时服务器端也创建一个同类型的对象，此时客户端和服务器段通过各自拥有的`TCPConn`对象来进行数据交换。一般而言，客户端通过`TCPConn`对象将请求信息发送到服务器端，读取服务器端响应的信息。服务器端读取并解析来自客户端的请求，并返回应答信息，这个连接只有当任一端关闭了连接之后才失效，不然这连接可以一直在使用。建立连接的函数定义如下： + + func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err os.Error) + +- net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only)、TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个) +- laddr表示本机地址，一般设置为nil +- raddr表示远程的服务地址 + +接下来我们写一个简单的例子，模拟一个基于HTTP协议的客户端请求去连接一个Web服务端。我们要写一个简单的http请求头，格式类似如下： + + "HEAD / HTTP/1.0\r\n\r\n" + +从服务端接收到的响应信息格式可能如下： + + HTTP/1.0 200 OK + ETag: "-9985996" + Last-Modified: Thu, 25 Mar 2010 17:51:10 GMT + Content-Length: 18074 + Connection: close + Date: Sat, 28 Aug 2010 00:43:48 GMT + Server: lighttpd/1.4.23 + +我们的客户端代码如下所示： + + package main + + import ( + "fmt" + "io/ioutil" + "net" + "os" + ) + + func main() { + if len(os.Args) != 2 { + fmt.Fprintf(os.Stderr, "Usage: %s host:port ", os.Args[0]) + os.Exit(1) + } + service := os.Args[1] + tcpAddr, err := net.ResolveTCPAddr("tcp4", service) + checkError(err) + conn, err := net.DialTCP("tcp", nil, tcpAddr) + checkError(err) + _, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n")) + checkError(err) + result, err := ioutil.ReadAll(conn) + checkError(err) + fmt.Println(string(result)) + os.Exit(0) + } + func checkError(err error) { + if err != nil { + fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) + os.Exit(1) + } + } + +通过上面的代码我们可以看出：首先程序将用户的输入作为参数`service`传入`net.ResolveTCPAddr`获取一个tcpAddr,然后把tcpAddr传入DialTCP后创建了一个TCP连接`conn`，通过`conn`来发送请求信息，最后通过`ioutil.ReadAll`从`conn`中读取全部的文本，也就是服务端响应反馈的信息。 + +### TCP server +上面我们编写了一个TCP的客户端程序，也可以通过net包来创建一个服务器端程序，在服务器端我们需要绑定服务到指定的非激活端口，并监听此端口，当有客户端请求到达的时候可以接收到来自客户端连接的请求。net包中有相应功能的函数，函数定义如下： + + func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err os.Error) + func (l *TCPListener) Accept() (c Conn, err os.Error) + +参数说明同DialTCP的参数一样。下面我们实现一个简单的时间同步服务，监听7777端口 + + package main + + import ( + "fmt" + "net" + "os" + "time" + ) + + func main() { + service := ":7777" + tcpAddr, err := net.ResolveTCPAddr("tcp4", service) + checkError(err) + listener, err := net.ListenTCP("tcp", tcpAddr) + checkError(err) + for { + conn, err := listener.Accept() + if err != nil { + continue + } + daytime := time.LocalTime().String() + conn.Write([]byte(daytime)) // don't care about return value + conn.Close() // we're finished with this client + } + } + func checkError(err error) { + if err != nil { + fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) + os.Exit(1) + } + } + +上面的服务跑起来之后，它将会一直在那里等待，直到有新的客户端请求到达。当有新的客户端请求到达并同意接受`Accept`该请求的时候他会反馈当前的时间信息。值得注意的是，在代码中`for`循环里，当有错误发生时，直接continue而不是退出，是因为在服务器端跑代码的时候，当有错误发生的情况下最好是由服务端记录错误，然后当前连接的客户端直接报错而退出，从而不会影响到当前服务端运行的整个服务。 + +上面的代码有个缺点，执行的时候是单任务的，不能同时接收多个请求，那么该如何改造以使它支持多并发呢？Go里面有一个goroutine机制，请看下面改造后的代码 + + package main + + import ( + "fmt" + "net" + "os" + "time" + ) + + func main() { + service := ":1200" + tcpAddr, err := net.ResolveTCPAddr("tcp4", service) + checkError(err) + listener, err := net.ListenTCP("tcp", tcpAddr) + checkError(err) + for { + conn, err := listener.Accept() + if err != nil { + continue + } + go handlerClient(conn) + } + } + + func handleClient(conn net.Conn) { + defer conn.Close() + daytime := time.Now().String() + conn.Write([]byte(daytime)) // don't care about return value + // we're finished with this client + } + func checkError(err error) { + if err != nil { + fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) + os.Exit(1) + } + } + +通过把业务处理分离到函数`handleClient`，我们就可以进一步地实现多并发执行了。看上去是不是很帅，增加`go`关键词就实现了服务端的多并发，从这个小例子也可以看出goroutine的强大之处。 + +### 控制TCP连接 +TCP有很多连接控制函数，我们平常用到比较多的有如下几个函数： + + func (c *TCPConn) SetTimeout(nsec int64) os.Error + func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error + +第一个函数用来设置连接的超时时间，客户端和服务器端都适用，当超过设置的时间时该连接就会失效。 + +第二个函数用来设置客户端是否和服务器端一直保持着连接，即使没有任何的数据发送。 + +更多的内容请查看`net`包的文档。 +## UDP Socket +Go语言包中处理UDP Socket和TCP Socket不同的地方就是在服务器端处理多个客户端请求数据包的方式不同,UDP缺少了对客户端连接请求的Accept函数。其他基本几乎一模一样，只有TCP换成了UDP而已。UDP的几个主要函数如下所示： + + func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error) + func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err os.Error) + func ListenUDP(net string, laddr *UDPAddr) (c *UDPConn, err os.Error) + func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error + func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error) + +一个UDP的客户端代码如下所示,我们可以看到不同的就是TCP换成了UDP而已： + + package main + + import ( + "fmt" + "net" + "os" + ) + + func main() { + if len(os.Args) != 2 { + fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0]) + os.Exit(1) + } + service := os.Args[1] + udpAddr, err := net.ResolveUDPAddr("udp4", service) + checkError(err) + conn, err := net.DialUDP("udp", nil, udpAddr) + checkError(err) + _, err = conn.Write([]byte("anything")) + checkError(err) + var buf [512]byte + n, err := conn.Read(buf[0:]) + checkError(err) + fmt.Println(string(buf[0:n])) + os.Exit(0) + } + func checkError(err error) { + if err != nil { + fmt.Fprintf(os.Stderr, "Fatal error ", err.Error()) + os.Exit(1) + } + } + +我们来看一下UDP服务器端如何来处理： + + package main + + import ( + "fmt" + "net" + "os" + "time" + ) + + func main() { + service := ":1200" + udpAddr, err := net.ResolveUDPAddr("udp4", service) + checkError(err) + conn, err := net.ListenUDP("udp", udpAddr) + checkError(err) + for { + handleClient(conn) + } + } + func handleClient(conn *net.UDPConn) { + var buf [512]byte + _, addr, err := conn.ReadFromUDP(buf[0:]) + if err != nil { + return + } + daytime := time.Now().String() + conn.WriteToUDP([]byte(daytime), addr) + } + func checkError(err error) { + if err != nil { + fmt.Fprintf(os.Stderr, "Fatal error ", err.Error()) + os.Exit(1) + } + } + +## 总结 +通过对TCP和UDP Socket编程的描述和实现，可见Go已经完备地支持了Socket编程，而且使用起来相当的方便，Go提供了很多函数，通过这些函数可以很容易就编写出高性能的Socket应用。 + + +## links + * [目录]() + * 上一节: [Web服务](<8.md>) + * 下一节: [WebSocket](<8.2.md>) diff --git a/9.1.md b/9.1.md index d74c537c..ddcec004 100644 --- a/9.1.md +++ b/9.1.md @@ -15,7 +15,7 @@ CSRF（Cross-site request forgery），中文名称：跨站请求伪造，也 从上图可以看出，要完成一次CSRF攻击，受害者必须依次完成两个步骤 ： - 1.登录受信任网站A，并在本地生成Cookie 。 -- 2.在不登出A的情况下，访问危险网站B。 +- 2.在不退出A的情况下，访问危险网站B。 看到这里，读者也许会问：“如果我不满足以上两个条件中的任意一个，就不会受到CSRF的攻击”。是的，确实如此，但你不能保证以下情况不会发生： diff --git a/README.md b/README.md index d96f8019..0e540c8c 100644 --- a/README.md +++ b/README.md @@ -30,9 +30,6 @@ 这样读者就可以把相应的Markdown文件编译成html文件，执行`go build build.go`，执行生成的文件，就会在底目录下生成相应的html文件 -## 如何编译 -目前可以把相应的Markdown编译成html文件，执行`go build build.go`，执行生成的文件，就会在底目录下生成相应的html文件。 - ## 交流 欢迎大家加入QQ群：259316004 《Go Web编程》专用交流群 diff --git a/images/13.1.flow.png b/images/13.1.flow.png new file mode 100644 index 00000000..b47e5bfc Binary files /dev/null and b/images/13.1.flow.png differ diff --git a/images/13.1.gopath.png b/images/13.1.gopath.png new file mode 100644 index 00000000..c948437a Binary files /dev/null and b/images/13.1.gopath.png differ diff --git a/images/13.1.gopath2.png b/images/13.1.gopath2.png new file mode 100644 index 00000000..450b4104 Binary files /dev/null and b/images/13.1.gopath2.png differ diff --git a/images/13.4.beego.png b/images/13.4.beego.png new file mode 100644 index 00000000..96a9d274 Binary files /dev/null and b/images/13.4.beego.png differ diff --git a/preface.md b/preface.md index d2523971..4c15541d 100644 --- a/preface.md +++ b/preface.md @@ -76,16 +76,17 @@ - 12.3 [应用部署](12.3.md) - 12.4 [备份和恢复](12.4.md) - 12.5 [小结](12.5.md) -* 13.构建博客系统　 - - 13.1 创建数据库表　 - - 13.2 建立对象类 - - 13.3 创建控制器管理博客帖子 - - 13.4 创建和编辑博客帖子　 - - 13.5 预览博客帖子 - - 13.6 更新博客帖子的状态 - - 13.7 小结　 -* 14.扩展博客管理系统　 - - 14.1 在博客管理系统索引页面上列出帖子 - - 14.2 为博客各月概要增加Ajax功能 - - 14.3 集成WYSIWYG编辑器 - - 14.4 小结　 \ No newline at end of file +* 13.[如何设计一个Web框架](13.md)　 + - 13.1 [项目规划](13.1.md)　 + - 13.2 [自定义路由器设计](13.2.md) + - 13.3 [controller设计](13.3.md) + - 13.4 [日志和配置设计](13.4.md) + - 13.5 [实现博客的增删改](13.5.md) + - 13.6 [小结](13.6.md)　 +* 14.[扩展Web框架](14.md) + - 14.1 [静态文件支持](14.1.md) + - 14.2 [Session支持](14.2.md) + - 14.3 [表单支持](14.3.md) + - 14.4 [用户认证](14.4.md) + - 14.5 [多语言支持](14.5.md) + - 14.6 [小结](14.6.md) \ No newline at end of file