用Golang搭建网站(函数语言请求代码对象)

本问适合有一定编程基础，但是没有Go语言基础的同学。

也就是俗称的“骗你”学Go语言系列。

这是一个适合阅读的系列，我希望您能够在车上、厕所、餐厅都阅读它，涉及代码的部分也是精简而实用的。

学习需要动机

Go语言能干什么？为什么要学习Go语言？

本系列文章，将会以编程开发中需求最大、应用最广的Web开发为例，一步一步的学习Go语言。
当看完本系列，您能够清晰的了解Go语言Web开发的基本原理，您会惊叹于Go语言的简洁、高效和新鲜。

结果反馈才能让你记住

《刻意练习》一书中说，学习需要及时反馈结果，才能提高学习体验。

本系列文章的每一节，都会包含一段可运行的有效代码，跟着内容一步一步操作，你可以在你自己的计算机上体验每一句代码的作用。

不要学习不需要的东西

文章围绕范例为核心，介绍知识点。
文中不罗列语法和关键字，当您还不知道它们用来干什么时，反而会干扰您的注意力。

希望您在阅读本系列文章后，对Go语言产生更多的学习欲望，成为一名合格的Gopher

1.下载Go语言安装文件

访问Go语言官方网站下载页面:

https://golang.org/dl

可以看到官网提供了Microsoft Windows、Apple MacOS、Linux和Source下载。

直接下载对应操作系统的安装包。

[图片上传失败...(image-591890-1557632893071)]

2.和其他软件一样，根据提示安装

3.配置环境变量

在正式使用Go编写代码之前，还有一个重要的“环境变量”需要配置：“$GOPATH”

GOPATH环境变量是用于设置Go编译可以执行文件、包源码以及依赖包所必要的工作目录路径，Go1.11后，新的木块管理虽然可以不再依赖 $GOPATH/src，但是依然需要使用 $GOPATH/pkg 路径来保存依赖包。

首先，创建好一个目录用作GOPATH目录

然后设置环境变量 GOPATH:

Linux & MacOS:

导入环境变量

$ export GOPATH=$YOUR_PATH/go

保存环境变量

$ source ~/.bash_profile

Windows:

控制面板->系统->高级系统设置->高级->环境变量设置

GOPATH所指定的目录会生成3个子目录：

4.检查环境

打开命令行工具，运行

$ go env

如果你看到类似这样的结果，说明Go语言环境安装完成.

GOARCH=\"amd64\" GOBIN=\"\" GOCACHE=\"/Users/zeta/Library/Caches/go-build\" GOEXE=\"\" GOFLAGS=\"\" GOHOSTARCH=\"amd64\" GOHOSTOS=\"darwin\" GOOS=\"darwin\" GOPATH=\"/Users/zeta/workspace/go\" GOPROXY=\"https://goproxy.io\" GORACE=\"\" GOROOT=\"/usr/local/go\" GOTMPDIR=\"\" GOTOOLDIR=\"/usr/local/go/pkg/tool/darwin_amd64\" GCCGO=\"gccgo\" CC=\"clang\" CXX=\"clang++\" CGO_ENABLED=\"1\" GOMOD=\"\" CGO_CFLAGS=\"-g -O2\" CGO_CPPFLAGS=\"\" CGO_CXXFLAGS=\"-g -O2\" CGO_FFLAGS=\"-g -O2\" CGO_LDFLAGS=\"-g -O2\" PKG_CONFIG=\"pkg-config\" GOGCCFLAGS=\"-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/7v/omg2000000000000019/T/go-build760324613=/tmp/go-build -gno-record-gcc-switches -fno-common\"

5.选择一款趁手的编辑器或IDE

现在很多通用的编辑器或IDE都支持Go语言比如

Go语言专用的IDE有

专用的IDE无论是配置和使用都比通用编辑器/IDE的简单许多，但是我还是推荐大家使用通用编辑器/IDE，因为在开发过程中肯定会需要编写一些其他语言的程序或脚本，专用IDE在其他语言编写方面较弱，来回切换不同的编辑器/IDE窗口会很低效。

另外，专用IDE提供很多高效的工具，在编译、调试方面都很方便，但是学习阶段，建议大家手动执行命令编译、调试，有利于掌握Go语言。

命令行代码仅适用于Linux和MacOS系统，Windows根据说明在视窗下操作即可。

1.创建项目

创建一个文件夹，进入该文件夹

$ mkdir gowebserver && cd gowebserver

新建一个文件 main.go

$ touch main.go

2. 用编辑器打开文件，并输入以下代码：

package main import \"fmt\" func main() { fmt.Println(\"Hello, 世界\") }

3.打开命令行终端，输入以下命令

$ go run main.go

看到终端会输出：

Hello, 世界

第一个Go代码就完成了

这是一个很简单的Hello World，但是包含了Go语言编程的许多核心元素，接下来就详细讲解。

解读知识点: 包 与 函数

package申明包 & import导入包

Go程序是由包构成的。

代码的第一行, 申明程序自己的包，用 package关键字。
package关键字必须是第一行出现的代码。

范例代码中，申明的本包名 main

在代码中第二行, 导入“fmt”包, 使用 import 关键字。
默认情况下，导入包的包名与导入路径的最后一个元素一致，例如 import \"math/rand\"，在代码中使用这个包时，直接使用rand，例如 rand.New()

导入包的写法可以多行,也可以“分组”, 例如:

import \"fmt\" import \"math/rand\"

或者 分组

import ( \"fmt\" \"math/rand\" )

func关键字：定义函数

func是function的缩写, 在Go语言中是定义函数的关键字。

func定义函数的格式为：

func 函数名(参数1 类型,参数2 类型){ 函数体 }

本例中定义了一个main函数。
main函数没有参数。
然后在main函数体里调用fmt包的Println函数，在控制台输出字符串 “Hello, 世界”

所有Go语言的程序的入口都是main包下的main函数 main.main()，所以每一个可执行的Go程序都应该有一个main包和一个main函数。

我们已经介绍了九牛一毛中的一毛，接下来正式通过搭建一个简单的Web服务学习Go语言

先从代码开始

打开之前创建好的main.go文件，修改代码如下:

package main import ( \"fmt\" \"net/http\" ) func myWeb(w http.ResponseWriter, r http.Request) { fmt.Fprintf(w, \"这是一个开始\") } func main() { http.HandleFunc(\"/\", myWeb) fmt.Println(\"服务器即将开启，访问地址 http://localhost:8080\") err := http.ListenAndServe(\":8080\", nil) if err != nil { fmt.Println(\"服务器开启错误: \", err) } }

保存文件，然后在命令行工具下输入命令，运行程序

$ go run main.go

这时候，你会看到用 fmt.Println打印出来的提示，在浏览器中访问 http://localhost:8080你将访问到一个页面，显示 \"这是一个开始\"

解读

我们从程序运行的顺序去了解它的工作流程

首先，定义package main，然后导入包。

这里，导入了一个新的包 net/http，这个包是官方的，实现http客户端和服务端的各种功能。
Go语言开发Web服务的所有功能就是基于这个包（其他第三方的Go语言Web框架也都基于这个包，没有例外）

先看main函数里发生了什么

第一句，匹配路由和处理函数

http.HandleFunc(\"/\", myWeb)

调用http包的HandleFunc方法，匹配一个路由到一个处理函数myWeb。

这句代码的意思是，当通过访问地址 http://localhost/ 时，就等同于调用了 myWeb 函数。

第二句，用fmt在控制台打印一句话，纯属提示。

第三句，开启服务并且监听端口

err := http.ListenAndServe(\":8080\", nil)

在这句，调用了http包中的ListenAndServe函数，该函数有两个参数，第一个是指定监听的端口号，第二个是指定处理请求的handler，通常这个参数填nil，表示使用默认的ServeMux作为handler。

什么是nil？

nil就是其他语言里的null。

ListenAndServe函数会一直监听，除非强制退出或者出现错误。

如果这句开启监听出现错误，函数会退出监听并会返回一个error类型的对象，因此用err变量接收返回对象。
紧接着，判断err是否为空，打印出错误内容，程序结束。

这里有两个Go语言知识点

1.定义变量

Go语言是静态语言，需要定义变量，定义变量用关键字var

var str string = \"my string\" //^ ^ ^ //关键字 变量名 类型

Go还提了一种简单的变量定义方式:=，自动根据赋值的对象定义变量类型，用起来很像脚本语言：

str := \"my string\"

2.错误处理

if err != nil{ //处理.... }

在Go语言中，这是很常见的错误处理操作，另一种panic异常，官方建议不要使用或尽量少用，暂不做介绍，先从err开始。

Go语言中规定，如果函数可能出现错误，应该返回一个error对象，这个对象至少包含一个Error()方法错误信息。

因此，在Go中，是看不到try/catch语句的，函数使用error传递错误，用if语句判断错误对象并且处理错误。

3. if 语句

与大多数语言使用方式一样，唯一的区别是，表达式不需要()包起来。

另外，Go语言中的if可以嵌入一个表达式，用;号隔开，例如范例中的代码可以改为：

if err := http.ListenAndServe(\":8080\", nil); err != nil { fmt.Println(\"服务器开启错误: \", err) }

err这个变量的生命周期只在if块中有效。

请求处理 myWeb函数

在main函数中，用http.HandleFunc将 myWeb与路由/匹配在一起。

HandleFunc函数定义了两个参数w,r，参数类型分别是http.ResponseWriter和http.Request，w是响应留写入器，r是请求对象的指针。

响应流写入器 w: 用来写入http响应数据

请求对象 r: 包含了http请求所有信息，注意，这里使用了指针，在定义参数时用标记类型，说明这个参数需要的是这个类型的对象的指针。

当有请求路径/，请求对象和响应流写入器被传递给myWeb函数，并由myWeb函数负责处理这次请求。

Go语言中红的指针： 在Go语言中 除了map、slice、chan 其他函数传参都是值传递，所以，如果需要达到引用传递的效果，通过传递对象的指针实现。
在Go语言中，取对象的指针用&，取值用，例如：

mystring := \"hi\" //取指针 mypointer := &mystring //取值 mystring2 := mypointer fmt.Println(mystring,mypointer,mystring2)

把这些代码放在main函数里，$ go run main.go运行看看

myWeb函数体

fmt.Fprintf(w, \"这是一个开始\")

再一次遇到老熟人fmt，这次使用他的Fprintf函数将字符串“这是一个开始”,写入到w响应流写入器对象。
w响应流写入器里写入的内容最后会被Response输出到用户浏览器的页面上。

总结一下，从编码到运行，你和它都干了些什么：

虽然代码很少很少，但是这就是一个最基本的Go语言Web服务程序了。

还是先从代码开始

打开main.go文件，修改myWeb函数，如下:

func myWeb(w http.ResponseWriter, r http.Request) { r.ParseForm() //它还将请求主体解析为表单，获得POST Form表单数据，必须先调用这个函数 for k, v := range r.URL.Query() { fmt.Println(\"key:\", k, \", value:\", v[0]) } for k, v := range r.PostForm { fmt.Println(\"key:\", k, \", value:\", v[0]) } fmt.Fprintln(w, \"这是一个开始\") }

运行程序

$ go run main.go

然后用任何工具（推荐Postman）提交一个POST请求，并且带上URL参数，或者在命令行中用cURL提交

curl --request POST \ --url 'http://localhost:8080/?name=zeta' \ --header 'cache-control: no-cache' \ --header 'content-type: application/x-www-form-urlencoded' \ --data description=hello

页面和终端命令行工具会答应出以下内容：

key: name , value: zeta key: description , value: hello

解读

http请求的所有内容，都保存在http.Request对象中，也就是myWeb获得的参数 r 。

首先，调用r.ParseForm()，作用是填充数据到 r.Form 和 r.PostForm

接下来，分别循环获取遍历打印出 r.URL.Query() 函数返回的值 和 r.PostForm值里的每一个参数。

r.URL.Query() 和 r.PostForm 分别是URL参数对象和表单参数对象 ，它们都是键值对值，键的类型是字符串string，值的类型是string数组。

循环遍历：for...range

Go语言的循环只有for关键字，以下是Go中4种for循环

//无限循环，阻塞线程，用不停息，慎用！
for{ } //条件循环，如果a<b，循环，否则，退出循环 for a < b{ } //表达式循环，设i为0，i小于10时循环，每轮循环后i增加1 for i:=0; i<10; i++{ } //for...range 遍历objs，objs必须是map、slice、chan类型 for k, v := range objs{ }

前3种，循环你可以看作条件循环的变体（无限循环就是无条件的循环）。

本例种用到的是 for...range 循环，遍历可遍历对象，并且每轮循环都会将键和值分别赋值给变量 k 和 v

我们页面还是只是输出一句“这是一个开始”。
我们需要一个可以见人的页面，这样可以不行

你也许也想到了，是不是可以在输出时，硬编码HTML字符串？当然可以，但是Go http包提供了更好的方式，HTML模版。

接下来，我们就用HTML模版做一个真正的页面出来

读取HTML模版文件，用数据替换掉对应的标签，生成完整的HTML字符串，响应给浏览器，这是所有Web开发框架的常规操作。
Go也是这么干的。

Go html包提供了这样的功能：

\"html/template\"

从代码开始

main函数不变，增加导入html/template包，然后修改myWeb函数，如下：

import ( \"fmt\" \"net/http\" \"text/template\" //导入模版包 ) func myWeb(w http.ResponseWriter, r http.Request) { t := template.New(\"index\") t.Parse(\"<div id='templateTextDiv'>Hi,{{.name}},{{.someStr}}</div>\") data := map[string]string{ \"name\": \"zeta\", \"someStr\": \"这是一个开始\", } t.Execute(w, data) // fmt.Fprintln(w, \"这是一个开始\") }

在命令行中运行 $ go run main.go ，访问 http://localhost:8080

看，<div id='templateTextDiv'>Hi,{{.name}},{{.someStr}}</div> 中的{{.name}}和{{.someStr}} 被替换成了 zeta和这是一个开始。
并且，不再使用fmt.Fprintln函数输出数据到Response了

但是...这还是在代码里硬编码HTML字符串啊...

别着急，template包可以解析文件，继续修改代码：

<html> <head></head> <body> <div>Hello {{.name}}</div> <div>{{.someStr}}</div> </body> </html>

func myWeb(w http.ResponseWriter, r http.Request) { //t := template.New(\"index\") //t.Parse(\"<div>Hi,{{.name}},{{.someStr}}<div>\") //将上两句注释掉，用下面一句 t, _ := template.ParseFiles(\"./templates/index.html\") data := map[string]string{ \"name\": \"zeta\", \"someStr\": \"这是一个开始\", } t.Execute(w, data) // fmt.Fprintln(w, \"这是一个开始\") }

在运行一下看看，页面按照HTML文件的内容输出了，并且{{.name}}和{{.someStr}}也替换了，对吧？

解读

可以看到，template包的核心功能就是将HTML字符串解析暂存起来，然后调用Execute的时候，用数据替换掉HTML字符串中的{{}}里面的内容

在第一个方式中 t:=template.New(\"index\") 初始化一个template对象变量，然后用调用t.Parse函数解析字符串模版。

然后，创建一个map对象，渲染的时候会用到。

最后，调用t.Execute函数，不仅用数据渲染模版，还替代了fmt.Fprintln函数的工作，将输出到Response数据流写入器中。

第二个方式中，直接调用 template包的ParseFiles函数，直接解析相对路径下的index.html文件并创建对象变量。

知识点

本节出现了两个新东西 map类型 和 赋值给“_”

map类型

map类型: 字典类型（键值对），之前的获取请求参数章节中出现的 url/values类型其实就是从map类型中扩展出来的

map的初始化可以使用make：

var data = make(map[string]string) data = map[string]string{}

map赋值于其他语言的字典对象相同，取值有两种方式，请看下面的代码：

data[\"name\"]=\"zeta\" //赋值 name := data[\"name\"] //方式1.普通取值 name,ok := data[\"name\"] //方式2.如果不存在name键，ok为false

Go中的map还有几个特点需要了解：

赋值给 “_”

Go有一个特点，变量定义后如果没使用，会报错，无法编译。
一般情况下没什么问题，但是极少情况下，我们调用函数，但是并不需要使用返回值，但是不使用，又无法编译，怎么办？

\"_\" 就是用来解决这个问题的，_用来丢弃函数的返回值。
比如本例中，template.ParseFiles(\"./templates/index.html\") 除了返回模版对象外，还会返回一个error对象，但是这样简单的例子，出错的可能性极小，所以我不想处理error了，将error返回值用“_”丢弃掉。

OK，到目前为止，用Go语言搭建一个简单的网页的核心部分就完成了。

等等 .js、.css、图片怎么办？

对。
例子里的模版全是HTML代码，一个漂亮的网页还必须用到图片、js脚本和css样式文件，可是...和PHP不同，请求路径是通过HandleFunc匹配到处理函数的，难道要把js、css和图片都通过函数输出后，再用HandleFunc和URL路径匹配？

以在index.html文件里引用一个index.js文件为例。

从代码开始

func main() { http.HandleFunc(\"/\", myWeb) //指定相对路径./static 为文件服务路径 staticHandle := http.FileServer(http.Dir(\"./static\")) //将/js/路径下的请求匹配到 ./static/js/下 http.Handle(\"/js/\", staticHandle) fmt.Println(\"服务器即将开启，访问地址 http://localhost:8080\") err := http.ListenAndServe(\":8080\", nil) if err != nil { fmt.Println(\"服务器开启错误: \", err) } }

在项目的根目录下创建static目录，进入static目录，创建js目录，然后在js目录里创建一个index.js文件。

alert(\"Javascript running...\");

打开之前的index.html文件,在后面加上 <script src=\"/js/index.js\"></script>

运行 $ go run main.go，访问 http://localhost:8080，页面会弹出提示框。

解读

页面在浏览器中运行时，当运行到<script src=\"/js/index.js\"></script>浏览器会请求 /js/index.js这个路径

程序检查到第一层路由匹配/js/，于是用文件服务处理这次请求，匹配到程序运行的路径下相对路径./static/js。

匹配的设置是 main.go文件中这两句

//指定相对路径./static 为文件服务路径 staticHandle := http.FileServer(http.Dir(\"./static\")) //将/js/路径下的请求匹配到 ./static/js/下 http.Handle(\"/js/\", staticHandle)

也可以写成一句，更容易理解

//浏览器访问/js/ 将会以静态文件形式访问目录 ./static/js http.Handle(\"/js/\", http.FileServer(http.Dir(\"./static\")))

很简单...但是，可能还是不满足需求，因为, 如果

http.Handle(\"/js/\", http.FileServer(http.Dir(\"./static\"))) 对应到 ./static/js

http.Handle(\"/css/\", http.FileServer(http.Dir(\"./static\"))) 对应到 ./static/css

http.Handle(\"/img/\", http.FileServer(http.Dir(\"./static\"))) 对应到 ./static/img

http.Handle(\"/upload/\", http.FileServer(http.Dir(\"./static\"))) 对应到 ./static/upload

这样所有请求的路径都必须匹配一个static目录下的子目录。

如果，我就想访问static目录下的文件，或者，js、css、img、upload目录就在项目根目录下怎么办？

http包下，还提供了一个函数 http.StripPrefix 剥开前缀，如下：

//http.Handle(\"/js/\", http.FileServer(http.Dir(\"./static\"))) //加上http.StripPrefix 改为 ： http.Handle(\"/js/\", http.StripPrefix(\"/js/\", http.FileServer(http.Dir(\"./static\"))))

这样，浏览器中访问/js/时，直接对应到./static目录下，不需要再加一个/js/子目录。

所以，如果需要再根目录添加多个静态目录，并且和URL的路径匹配，可以这样：

http.Handle(\"/js/\", http.StripPrefix(\"/js/\", http.FileServer(http.Dir(\"./js\")))) 对应到 ./js

http.Handle(\"/css/\", http.StripPrefix(\"/css/\", http.FileServer(http.Dir(\"./css\")))) 对应到 ./css

http.Handle(\"/img/\", http.StripPrefix(\"/img/\", http.FileServer(http.Dir(\"./img\")))) 对应到 ./img

http.Handle(\"/upload/\", http.StripPrefix(\"/upload/\", http.FileServer(http.Dir(\"./upload\")))) 对应到 ./upload

到这里，一个从流程上完整的Web服务程序就介绍完了。

整理一下，一个Go语言的Web程序基本的流程：

当有http请求时：

最后编译程序

之前调试都使用的是 go run 命令运行程序。

您会发现，每次运行go run都会重新编译源码，如何将程序运行在没有Go环境的计算机上？

使用 go build 命令，它会编译源码，生成可执行的二进制文件。

最简单的 go build 命令什么参数都不用加，它会自动查找目录下的main包下的main()函数，然后依次查找依赖包编译成一个可执行文件。

其他依赖文件的相对路径需要和编译成功后的可执行文件一致，例如范例中的templates文件夹和static文件夹。

默认情况下，go build会编译为和开发操作系统对应的可执行文件，如果要编译其他操作系统的可执行文件，需要用到交叉编译。

例如将Linux和MacOSX系统编译到windows

GOOS=windows GOARCH=amd64 go build

在Windows上需要使用SET命令, 例如在Windows上编译到Linux系统

SET GOOS=linux SET GOARCH=amd64 go build main.go

学到了什么？

本系列内容很少，很简洁，希望您能对Go多一点点了解，对Go多增加一点点兴趣。

没有涉及的其他知识

还有很多内容成为一个合格的Gopher必须要了解的知识

以后的文章中会涉及更多关于Go语言编程的内