Golang语言社区--go语言编写Web程序

1. 简介

这个例子涉及到的技术:

  • 创建一个数据类型,含有load和save函数
  • 基于http包创建web程序
  • 基于template包的html模板技术
  • 使用regexp包验证用户输入
  • 使用闭包

假设读者有以下知识:

  • 基本的编程经验
  • web程序的基础技术(HTTP, HTML)
  • UNIX 命令行

2. 开始

首先,要有一个Linux, OS X, or FreeBSD系统,可以运行go程序。如果没有的话,可以安装一个虚拟机(如VirtualBox)或者 Virtual Private Server。

安装Go环境: (请参考 Installation Instructions).

创建一个新的目录,并且进入该目录:

 $ mkdir ~/gowiki
  $ cd ~/gowiki

创建一个wiki.go文件,用你喜欢的编辑器打开,然后添加以下代码:

package main
  
  import (
          "fmt"
          "io/ioutil"
          "os"
  )

我们从go的标准库导入fmt, ioutil 和 os包。 以后,当实现其他功能时,我们会根据需要导入更多包。

3. 数据结构

我们先定义一个结构类型,用于保存数据。wiki系统由一组互联的wiki页面组成,每个wiki页面包含内容和标题。我们定义wiki页面为结构page, 如下:

 type page struct {
          title        string
          body        []byte
  }

类型[]byte表示一个byte slice。(参考Effective Go了解slices的更多信息) 成员body之所以定义为[]byte而不是string类型,是因为[]byte可以直接使用io包的功能。

结构体page描述了一个页面在内存中的存储方式。但是,如果要将数据保存到磁盘的话,还需要给page类型增加save方法:

func (p *page) save() os.Error {
          filename := p.title + ".txt"
          return ioutil.WriteFile(filename, p.body, 0600)
  }

类型方法的签名可以这样解读:“save为page类型的方法,方法的调用者为page类型的指针变量p。该成员函数没有参数,返回值为os.Error,表示错误信息。”

该方法会将page结构的body部分保存到文本文件中。为了简单,我们用title作为文本文件的名字。

方法save的返回值类型为os.Error,对应WriteFile(标准库函数,将byte slice写到文件中)的返回值。通过返回os.Error值,可以判断发生错误的类型。如果没有错误,那么返回nil(指针、接口和其他一些类型的零值)。

WriteFile的第三个参数为八进制的0600,表示仅当前用户拥有新创建文件的读写权限。(参考Unix手册 open(2) )

下面的函数加载一个页面:

 func loadPage(title string) *page {
          filename := title + ".txt"
          body, _ := ioutil.ReadFile(filename)
          return &page{title: title, body: body}
  }

函数loadPage根据页面标题从对应文件读取页面的内容,并且构造一个新的 page变量——对应一个页面。

go中函数(以及成员方法)可以返回多个值。标准库中的io.ReadFile在返回[]byte的同时还返回os.Error类型的错误信息。前面的代码中我们用下划线“_”丢弃了错误信息。

但是ReadFile可能会发生错误,例如请求的文件不存在。因此,我们给函数的返回值增加一个错误信息。

 func loadPage(title string) (*page, os.Error) {
          filename := title + ".txt"
          body, err := ioutil.ReadFile(filename)
          if err != nil {
                  return nil, err
          }
          return &page{title: title, body: body}, nil
  }

现在调用者可以检测第二个返回值,如果为nil就表示成功装载页面。否则,调用者可以得到一个os.Error对象。(关于错误的更多信息可以参考os package documentation)

现在,我们有了一个简单的数据结构,可以保存到文件中,或者从文件加载。我们创建一个main函数,测试相关功能。

  func main() {
          p1 := &page{title: "TestPage", body: []byte("This is a sample page.")}
          p1.save()
          p2, _ := loadPage("TestPage")
          fmt.Println(string(p2.body))
  }

编译后运行以上程序的话,会创建一个TestPage.txt文件,用于保存p1对应的页面内容。然后,从文件读取页面内容到p2,并且将p2的值打印到 屏幕。

可以用类似以下命令编译运行程序:

$ 8g wiki.go
  $ 8l wiki.8
  $ ./8.out
  This is a sample page.

(命令8g和8l对应GOARCH=386。如果是amd64系统,可以用6g和6l)

点击这里查看我们当前的代码。

4. 使用http包

下面是一个完整的web server例子:

package main
  
  import (
          "fmt"
          "http"
  )
  
  func handler(w http.ResponseWriter, r *http.Request) {
          fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
  }
  
  func main() {
          http.HandleFunc("/", handler)
          http.ListenAndServe(":8080", nil)
  }

在main函数中,http.HandleFunc设置所有对根目录请求的处理函数为handler。

然后调用http.ListenAndServe,在8080端口开始监听(第二个参数暂时可以忽略)。然后程序将阻塞,直到退出。

函数handler为http.HandlerFunc类型,它包含http.Conn和http.Request两个类型的参数。

其中http.Conn对应服务器的http连接,我们可以通过它向客户端发送数据。

类型为http.Request的参数对应一个客户端请求。其中r.URL.Path 为请求的地址,它是一个string类型变量。我们用[1:]在Path上创建 一个slice,对应"/"之后的路径名。

启动该程序后,通过浏览器访问以下地址:

http://localhost:8080/monkeys

会看到以下输出内容:

Hi there, I love monkeys!

5. 基于http提供wiki页面

要使用http包,先将其导入:

import (
          "fmt"
          "http"
          "io/ioutil"
          "os"
  )

然后创建一个用于浏览wiki的函数:

const lenPath = len("/view/")
  
  func viewHandler(w http.ResponseWriter, r *http.Request) {
          title := r.URL.Path[lenPath:]
          p, _ := loadPage(title)
          fmt.Fprintf(w, "
%s
%s
", p.title, p.body)
  }

首先,这个函数从r.URL.Path(请求URL的path部分)中解析页面标题。全局常量lenPath保存"/view/"的长度,它是请求路径的前缀部分。Path总是以"/view/"开头,去掉前面的6个字符就可以得到页面标题。

然后加载页面数据,格式化为简单的HTML字符串,写到c中,c是一个http.Conn类型的参数。

注意这里使用下划线“_”忽略loadPage的os.Error返回值。 这不是一种好的做法,此处是为了保持简单。我们将在后面考虑这个问题。

为了使用这个处理函数(handler),我们创建一个main函数。它使用viewHandler初始化http,把所有以/view/开头的请求转发给viewHandler处理。

func main() {
          http.HandleFunc("/view/", viewHandler)
          http.ListenAndServe(":8080", nil)
  }

点击这里查看我们当前的代码。

让我们创建一些页面数据(例如as test.txt),编译,运行。

$ echo "Hello world" > test.txt
  $ 8g wiki.go
  $ 8l wiki.8
  $ ./8.out

当服务器运行的时候,访问http://localhost:8080/view/test将显示一个页面,标题为“test”,内容为“Hello world”。

6. 编辑页面

编辑功能是wiki不可缺少的。现在,我们创建两个新的处理函数(handler):editHandler显示"edit page"表单(form),saveHandler保存表单(form)中的数据。

首先,将他们添加到main()函数中:

func main() {
          http.HandleFunc("/view/", viewHandler)
          http.HandleFunc("/edit/", editHandler)
          http.HandleFunc("/save/", saveHandler)
          http.ListenAndServe(":8080", nil)
  }

函数editHandler加载页面(或者,如果页面不存在,创建一个空page 结构)并且显示为一个HTML表单(form)。

func editHandler(w http.ResponseWriter, r *http.Request) {
          title := r.URL.Path[lenPath:]
          p, err := loadPage(title)
          if err != nil {
                  p = &page{title: title}
          }
          fmt.Fprintf(w, "
Editing %s
"+
                  "
"+
                  "
%s

"+
                  "
\"Save\"
"+
                  "
",
                  p.title, p.title, p.body)
  }

这个函数能够工作,但是硬编码的HTML非常丑陋。当然,我们有更好的办法。

7. template包

template包是GO语言标准库的一个部分。我们使用template将HTML存放在一个单独的文件中,可以更改编辑页面的布局而不用修改相关的GO代码。

首先,我们必须将template添加到导入列表:

import (
          "http"
          "io/ioutil"
          "os"
          "template"
  )

创建一个包含HTML表单的模板文件。打开一个名为edit.html的新文件,添加下面的行:

Editing {title}

  
  

  

{body|html}

  

  

修改editHandler,用模板替代硬编码的HTML。

func editHandler(w http.ResponseWriter, r *http.Request) {
          title := r.URL.Path[lenPath:]
          p, err := loadPage(title)
          if err != nil {
                  p = &page{title: title}
          }
          t, _ := template.ParseFile("edit.html", nil)
          t.Execute(p, w)
  }

函数template.ParseFile读取edit.html的内容,返回*template.Template类型的数据。

方法t.Execute用p.title和p.body的值替换模板中所有的{title}和{body},并且把结果写到http.Conn。

注意,在上面的模板中我们使用{body|html}。|html部分请求模板引擎在输出body的值之前,先将它传到html格式化器(formatter),转义HTML字符(比如用>替换>)。 这样做,可以阻止用户数据破坏表单HTML。

既然我们删除了fmt.Sprintf语句,我们可以删除导入列表中的"fmt"。

使用模板技术,我们可以为viewHandler创建一个模板,命名为view.html。

{title}

  
  
[edit]


  
  
{body}

修改viewHandler:

 func viewHandler(w http.ResponseWriter, r *http.Request) {
          title := r.URL.Path[lenPath:]
          p, _ := loadPage(title)
          t, _ := template.ParseFile("view.html", nil)
          t.Execute(p, w)
  }

注意,在两个处理函数(handler)中使用了几乎完全相同的模板处理代码,我们可以把模板处理代码写成一个单独的函数,以消除重复。

func viewHandler(w http.ResponseWriter, r *http.Request) {
          title := r.URL.Path[lenPath:]
          p, _ := loadPage(title)
          renderTemplate(w, "view", p)
  }
  
  func editHandler(w http.ResponseWriter, r *http.Request) {
          title := r.URL.Path[lenPath:]
          p, err := loadPage(title)
          if err != nil {
                  p = &page{title: title}
          }
          renderTemplate(w, "edit", p)
  }
  
  func renderTemplate(w http.ResponseWriter, tmpl string, p *page) {
          t, _ := template.ParseFile(tmpl+".html", nil)
          t.Execute(p, w)
  }

现在,处理函数(handler)代码更短、更加简单。

8. 处理不存在的页面

当你访问/view/APageThatDoesntExist的时候会发生什么?程序将会崩溃。因为我们忽略了loadPage返回的错误。请求页不存在的时候,应该重定向客户端到编辑页,这样新的页面将会创建。

func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
          p, err := loadPage(title)
          if err != nil {
                  http.Redirect(w, r, "/edit/"+title, http.StatusFound)
                  return
          }
          renderTemplate(w, "view", p)
  }

函数http.Redirect添加HTTP状态码http.StatusFound (302)和报头Location到HTTP响应。

9. 储存页面

函数saveHandler处理表单提交。

  func saveHandler(w http.ResponseWriter, r *http.Request) {
          title := r.URL.Path[lenPath:]
          body := r.FormValue("body")
          p := &page{title: title, body: []byte(body)}
          p.save()
          http.Redirect(w, r, "/view/"+title, http.StatusFound)
  }

页面标题(在URL中)和表单中唯一的字段,body,储存在一个新的page中。然后调用save()方法将数据写到文件中,并且将客户重定向到/view/页面。

FormValue返回值的类型是string,在将它添加到page结构前,我们必须将其转换为[]byte类型。我们使用[]byte(body)执行转换。

10. 错误处理

在我们的程序中,有几个地方的错误被忽略了。这是一种很糟糕的方式,特别是在错误发生后,程序会崩溃。更好的方案是处理错误并返回错误消息给用户。这样做,当错误发生后,服务器可以继续运行,用户也会得到通知。

首先,我们处理renderTemplate中的错误:

  func renderTemplate(w http.ResponseWriter, tmpl string, p *page) {
          t, err := template.ParseFile(tmpl+".html", nil)
          if err != nil {
                  http.Error(w, err.String(), http.StatusInternalServerError)
                  return
          }
          err = t.Execute(p, w)
          if err != nil {
                  http.Error(w, err.String(), http.StatusInternalServerError)
          }
  }

函数http.Error发送一个特定的HTTP响应码(在这里表示“Internal Server Error”)和错误消息。

现在,让我们修复saveHandler:

  func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
          body := r.FormValue("body")
          p := &page{title: title, body: []byte(body)}
          err := p.save()
          if err != nil {
                  http.Error(w, err.String(), http.StatusInternalServerError)
                  return
          }
          http.Redirect(w, r, "/view/"+title, http.StatusFound)
  }

p.save()中发生的任何错误都将报告给用户。

11. 模板缓存

代码中有一个低效率的地方:每次显示一个页面,renderTemplate都要调用ParseFile。更好的做法是在程序初始化的时候对每个模板调用ParseFile一次,将结果保存为*Template类型的值,在以后使用。

首先,我们创建一个全局map,命名为templates。templates用于储存*Template类型的值,使用string索引。

然后,我们创建一个init函数,init函数会在程序初始化的时候调用,在main函数之前。函数template.MustParseFile是ParseFile的一个封装,它不返回错误码,而是在错误发生的时候抛出(panic)一个错误。抛出错误(panic)在这里是合适的,如果模板不能加载,程序唯一能做的有意义的事就是退出。

func init() { for _, tmpl := range []string{"edit", "view"} { templates[tmpl] = template.MustParseFile(tmpl+".html", nil) } }

使用带range语句的for循环访问一个常量数组中的每一个元素,这个常量数组中包含了我们想要加载的所有模板的名称。如果我们想要添加更多的模板,只要把模板名称添加的数组中就可以了。

修改renderTemplate函数,在templates中相应的Template上调用Execute方法:

func renderTemplate(w http.ResponseWriter, tmpl string, p *page) {
          err := templates[tmpl].Execute(p, w)
          if err != nil {
                  http.Error(w, err.String(), http.StatusInternalServerError)
          }
  }

12. 验证

你可能已经发现,程序中有一个严重的安全漏洞:用户可以提供任意的路径在服务器上执行读写操作。为了消除这个问题,我们使用正则表达式验证页面的标题。

首先,添加"regexp"到导入列表。然后创建一个全局变量存储我们的验证正则表达式:

函数regexp.MustCompile解析并且编译正则表达式,返回一个regexp.Regexp对象。和template.MustParseFile类似,当表达式编译错误时,MustCompile抛出一个错误,而Compile在它的第二个返回参数中返回一个os.Error。

现在,我们编写一个函数,它从请求URL解析中解析页面标题,并且使用titleValidator进行验证:

func getTitle(w http.ResponseWriter, r *http.Request) (title string, err os.Error) {
          title = r.URL.Path[lenPath:]
          if !titleValidator.MatchString(title) {
                  http.NotFound(w, r)
                  err = os.NewError("Invalid Page Title")
          }
          return
  }

如果标题有效,它返回一个nil错误值。如果无效,它写"404 Not Found"错误到HTTP连接中,并且返回一个错误对象。

修改所有的处理函数,使用getTitle获取页面标题:

func viewHandler(w http.ResponseWriter, r *http.Request) {
          title, err := getTitle(w, r)
          if err != nil {
                  return
          }
          p, err := loadPage(title)
          if err != nil {
                  http.Redirect(w, r, "/edit/"+title, http.StatusFound)
                  return
          }
          renderTemplate(w, "view", p)
  }
  
  func editHandler(w http.ResponseWriter, r *http.Request) {
          title, err := getTitle(w, r)
          if err != nil {
                  return
          }
          p, err := loadPage(title)
          if err != nil {
                  p = &page{title: title}
          }
          renderTemplate(w, "edit", p)
  }
  
  func saveHandler(w http.ResponseWriter, r *http.Request) {
          title, err := getTitle(w, r)
          if err != nil {
                  return
          }
          body := r.FormValue("body")
          p := &page{title: title, body: []byte(body)}
          err = p.save()
          if err != nil {
                  http.Error(w, err.String(), http.StatusInternalServerError)
                  return
          }
          http.Redirect(w, r, "/view/"+title, http.StatusFound)
  }

13. 函数文本和闭包

处理函数(handler)中捕捉错误是一些类似的重复代码。如果我们想将捕捉错误的代码封装成一个函数,应该怎么做?GO的函数文本提供了强大的抽象能力,可以帮我们做到这点。

首先,我们重写每个处理函数的定义,让它们接受标题字符串:

定义一个封装函数,接受上面定义的函数类型,返回http.HandlerFunc(可以传送给函数http.HandleFunc)。

func makeHandler(fn func (http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
          return func(w http.ResponseWriter, r *http.Request) {
                  // Here we will extract the page title from the Request,
                  // and call the provided handler 'fn'
          }
  }

返回的函数称为闭包,因为它包含了定义在它外面的值。在这里,变量fn(makeHandler的唯一参数)被闭包包含。fn是我们的处理函数,save、edit、或view。

我们可以把getTitle的代码复制到这里(有一些小的变动):

func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
          return func(w http.ResponseWriter, r *http.Request) {
                  title := r.URL.Path[lenPath:]
                  if !titleValidator.MatchString(title) {
                          http.NotFound(w, r)
                          return
                  }
                  fn(w, r, title)
          }
  }

makeHandler返回的闭包是一个函数,它有两个参数,http.Conn和http.Request(因此,它是http.HandlerFunc)。闭包从请求路径解析title,使用titleValidator验证标题。如果title无效,使用函数http.NotFound将错误写到Conn。如果title有效,封装的处理函数fn将被调用,参数为Conn, Request, 和title。

在main函数中,我们用makeHandler封装所有处理函数:

func main() {
          http.HandleFunc("/view/", makeHandler(viewHandler))
          http.HandleFunc("/edit/", makeHandler(editHandler))
          http.HandleFunc("/save/", makeHandler(saveHandler))
          http.ListenAndServe(":8080", nil)
  }

最后,我们可以删除处理函数中的getTitle,让处理函数更简单。

func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
          p, err := loadPage(title)
          if err != nil {
                  http.Redirect(w, r, "/edit/"+title, http.StatusFound)
                  return
          }
          renderTemplate(w, "view", p)
  }
  
  func editHandler(w http.ResponseWriter, r *http.Request, title string) {
          p, err := loadPage(title)
          if err != nil {
                  p = &page{title: title}
          }
          renderTemplate(w, "edit", p)
  }
  
  func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
          body := r.FormValue("body")
          p := &page{title: title, body: []byte(body)}
          err := p.save()
          if err != nil {
                  http.Error(w, err.String(), http.StatusInternalServerError)
                  return
          }
          http.Redirect(w, r, "/view/"+title, http.StatusFound)
  }

14. 试试!

点击这里查看最终的代码

重新编译代码,运行程序:

$ 8g wiki.go
  $ 8l wiki.8
  $ ./8.out

访问http://localhost:8080/view/ANewPage将会出现一个编辑表单。你可以输入一些文版,点击“Save”,重定向到新的页面。

15. 其他任务

这里有一些简单的任务,你可以自己解决:

  • 把模板文件存放在tmpl/目录,页面数据存放在data/目录。
  • 增加一个处理函数(handler),将对根目录的请求重定向到/view/FrontPage。
  • 修饰页面模板,使其成为有效的HTML文件。添加CSS规则。
  • 实现页内链接。将[PageName]修改为PageName。(提示:可以使用regexp.ReplaceAllFunc达到这个效果)

原文链接:http://www.golang.ltd/forum.php?mod=viewthread&tid=6863&extra=page%3D1

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏阿杜的世界

Java Web技术经验总结(十七)

542
来自专栏互扯程序

毕业季,跳槽季,不刷点面试题怎么能行?

现在是资源共享的时代,同样也是知识分享的时代,如果你觉得本文能学到知识,请把知识与别人分享。 前言 马上就是一年一度的毕业季 跳槽季,找工作三大要素,简...

3155
来自专栏鸿的学习笔记

聊聊python的一些常见工具

关于性能测试,主要是针对哪个函数调用过多,或者占用太多内存,或者导致太多的磁盘和网络I/O 首先是IPython的%timeit和time.time()...

1043
来自专栏MasiMaro 的技术博文

MFC中属性表单和向导对话框的使用

每次在使用MFC创建一个框架时,需要一步步选择自己的程序的外观,基本功能等选项,最后MFC会生成一个基本的程序框架,这个就是向导对话框;而属性表单则是另外一种对...

791
来自专栏向治洪

深入理解React Native页面构建渲染原理

前言 React Native 是最近非常火的一个话题,因为它的语法简介,跨平台等特性,赢得了各大平台的青睐,虽然前期是有一些坑。 基本概念解释 React 是...

27210
来自专栏程序员互动联盟

linux设备驱动第三篇:如何写一个简单的字符设备驱动

在linux设备驱动第一篇:设备驱动程序简介中简单介绍了字符驱动,本篇简单介绍如何写一个简单的字符设备驱动。本篇借鉴LDD中的源码,实现一个与硬件设备无关的字符...

33714
来自专栏前端杂货铺

objC与js通信实现--WebViewJavascriptBridge

场景   在移动端开发中,最为流行的开发模式就是hybmid开发,在这种native和h5的杂糅下,既能在某些需求中保证足够的性能,也可以在某些列表详情的需求下...

36510
来自专栏北京马哥教育

Python 性能优化的20条招数

? 优化算法时间复杂度 算法的时间复杂度对程序的执行效率影响最大,在 Python 中可以通过选择合适的数据结构来优化时间复杂度,如 list 和 set 查...

3336
来自专栏逸鹏说道

初识SignalR~仿QQ即时聊天(群发,单发)(Web,WPF等Demo演示)【中】

第二个阶段: QQ聊天案例,先讲一种常规的方法,下面会讲一种简单方法 先看看gif效果图把 ? 定义一个BaseHub类,里面用 qqModeList来...

3226
来自专栏狐狸

适配器模式(Adapter)

定义:适配器模式将某个类的接口转换成客户端期望的另一个接口表示,主的目的是兼容性,让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapp...

401

扫码关注云+社区