lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format and remove 08.1.md spaces

Browse Source
This commit is contained in:
vCaesar
2017-06-10 12:13:58 +08:00
parent b3b60272c3
commit 3abc8db54e
1 changed files with 225 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

450
zh/08.1.md
View File

@@ -33,33 +33,33 @@ IPv6是下一版本的互联网协议，也可以说是下一代互联网的协
在Go的`net`包中定义了很多类型、函数和方法用来网络编程，其中IP的定义如下： 在Go的`net`包中定义了很多类型、函数和方法用来网络编程，其中IP的定义如下：
```Go ```Go
type IP []byte type IP []byte
``` ```
在`net`包中有很多函数来操作IP，但是其中比较有用的也就几个，其中`ParseIP(s string) IP`函数会把一个IPv4或者IPv6的地址转化成IP类型，请看下面的例子: 在`net`包中有很多函数来操作IP，但是其中比较有用的也就几个，其中`ParseIP(s string) IP`函数会把一个IPv4或者IPv6的地址转化成IP类型，请看下面的例子:
```Go ```Go
package main package main
import ( import (
"net" "net"
"os" "os"
"fmt" "fmt"
) )
func main() { func main() {
if len(os.Args) != 2 { if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, "Usage: %s ip-addr\n", os.Args[0]) fmt.Fprintf(os.Stderr, "Usage: %s ip-addr\n", os.Args[0])
os.Exit(1) 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)
} }
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格式 执行之后你就会发现只要你输入一个IP地址就会给出相应的IP格式
@@ -71,8 +71,8 @@ IPv6是下一版本的互联网协议，也可以说是下一代互联网的协
```Go ```Go
func (c *TCPConn) Write(b []byte) (n int, err os.Error) func (c *TCPConn) Write(b []byte) (n int, err os.Error)
func (c *TCPConn) Read(b []byte) (n int, err os.Error) func (c *TCPConn) Read(b []byte) (n int, err os.Error)
``` ```
`TCPConn`可以用在客户端和服务器端来读写数据。 `TCPConn`可以用在客户端和服务器端来读写数据。
@@ -81,16 +81,16 @@ IPv6是下一版本的互联网协议，也可以说是下一代互联网的协
```Go ```Go
type TCPAddr struct { type TCPAddr struct {
IP IP IP IP
Port int Port int
} }
``` ```
在Go语言中通过`ResolveTCPAddr`获取一个`TCPAddr` 在Go语言中通过`ResolveTCPAddr`获取一个`TCPAddr`
```Go ```Go
func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error) func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error)
``` ```
- net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only),TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个). - net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only),TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个).
@@ -102,7 +102,7 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
```Go ```Go
func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err os.Error) 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的任意一个) - net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only)、TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个)
- laddr表示本机地址，一般设置为nil - laddr表示本机地址，一般设置为nil
@@ -115,49 +115,49 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
从服务端接收到的响应信息格式可能如下： 从服务端接收到的响应信息格式可能如下：
```Go ```Go
HTTP/1.0 200 OK HTTP/1.0 200 OK
ETag: "-9985996" ETag: "-9985996"
Last-Modified: Thu, 25 Mar 2010 17:51:10 GMT Last-Modified: Thu, 25 Mar 2010 17:51:10 GMT
Content-Length: 18074 Content-Length: 18074
Connection: close Connection: close
Date: Sat, 28 Aug 2010 00:43:48 GMT Date: Sat, 28 Aug 2010 00:43:48 GMT
Server: lighttpd/1.4.23 Server: lighttpd/1.4.23
``` ```
我们的客户端代码如下所示： 我们的客户端代码如下所示：
```Go ```Go
package main package main
import ( import (
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"net" "net"
"os" "os"
) )
func main() { func main() {
if len(os.Args) != 2 { if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, "Usage: %s host:port ", os.Args[0]) fmt.Fprintf(os.Stderr, "Usage: %s host:port ", os.Args[0])
os.Exit(1) 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) { service := os.Args[1]
if err != nil { tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) checkError(err)
os.Exit(1) 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`中读取全部的文本，也就是服务端响应反馈的信息。 通过上面的代码我们可以看出：首先程序将用户的输入作为参数`service`传入`net.ResolveTCPAddr`获取一个tcpAddr,然后把tcpAddr传入DialTCP后创建了一个TCP连接`conn`，通过`conn`来发送请求信息，最后通过`ioutil.ReadAll`从`conn`中读取全部的文本，也就是服务端响应反馈的信息。
@@ -166,43 +166,43 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
上面我们编写了一个TCP的客户端程序，也可以通过net包来创建一个服务器端程序，在服务器端我们需要绑定服务到指定的非激活端口，并监听此端口，当有客户端请求到达的时候可以接收到来自客户端连接的请求。net包中有相应功能的函数，函数定义如下： 上面我们编写了一个TCP的客户端程序，也可以通过net包来创建一个服务器端程序，在服务器端我们需要绑定服务到指定的非激活端口，并监听此端口，当有客户端请求到达的时候可以接收到来自客户端连接的请求。net包中有相应功能的函数，函数定义如下：
```Go ```Go
func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err os.Error) func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err os.Error)
func (l *TCPListener) Accept() (c Conn, err os.Error) func (l *TCPListener) Accept() (c Conn, err os.Error)
``` ```
参数说明同DialTCP的参数一样。下面我们实现一个简单的时间同步服务，监听7777端口 参数说明同DialTCP的参数一样。下面我们实现一个简单的时间同步服务，监听7777端口
```Go ```Go
package main package main
import ( import (
"fmt" "fmt"
"net" "net"
"os" "os"
"time" "time"
) )
func main() { func main() {
service := ":7777" service := ":7777"
tcpAddr, err := net.ResolveTCPAddr("tcp4", service) tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
checkError(err) checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr) listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err) checkError(err)
for { for {
conn, err := listener.Accept() conn, err := listener.Accept()
if err != nil {
continue
}
daytime := time.Now().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 { if err != nil {
fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) continue
os.Exit(1)
} }
daytime := time.Now().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而不是退出，是因为在服务器端跑代码的时候，当有错误发生的情况下最好是由服务端记录错误，然后当前连接的客户端直接报错而退出，从而不会影响到当前服务端运行的整个服务。 上面的服务跑起来之后，它将会一直在那里等待，直到有新的客户端请求到达。当有新的客户端请求到达并同意接受`Accept`该请求的时候他会反馈当前的时间信息。值得注意的是，在代码中`for`循环里，当有错误发生时，直接continue而不是退出，是因为在服务器端跑代码的时候，当有错误发生的情况下最好是由服务端记录错误，然后当前连接的客户端直接报错而退出，从而不会影响到当前服务端运行的整个服务。
@@ -210,42 +210,42 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
上面的代码有个缺点，执行的时候是单任务的，不能同时接收多个请求，那么该如何改造以使它支持多并发呢？Go里面有一个goroutine机制，请看下面改造后的代码 上面的代码有个缺点，执行的时候是单任务的，不能同时接收多个请求，那么该如何改造以使它支持多并发呢？Go里面有一个goroutine机制，请看下面改造后的代码
```Go ```Go
package main package main
import ( import (
"fmt" "fmt"
"net" "net"
"os" "os"
"time" "time"
) )
func main() { func main() {
service := ":1200" service := ":1200"
tcpAddr, err := net.ResolveTCPAddr("tcp4", service) tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
checkError(err) checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr) listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err) checkError(err)
for { for {
conn, err := listener.Accept() conn, err := listener.Accept()
if err != nil {
continue
}
go handleClient(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 { if err != nil {
fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) continue
os.Exit(1)
} }
go handleClient(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的强大之处。 通过把业务处理分离到函数`handleClient`，我们就可以进一步地实现多并发执行了。看上去是不是很帅，增加`go`关键词就实现了服务端的多并发，从这个小例子也可以看出goroutine的强大之处。
@@ -253,43 +253,43 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
有的朋友可能要问：这个服务端没有处理客户端实际请求的内容。如果我们需要通过从客户端发送不同的请求来获取不同的时间格式，而且需要一个长连接，该怎么做呢？请看： 有的朋友可能要问：这个服务端没有处理客户端实际请求的内容。如果我们需要通过从客户端发送不同的请求来获取不同的时间格式，而且需要一个长连接，该怎么做呢？请看：
```Go ```Go
package main package main
import ( import (
"fmt" "fmt"
"net" "net"
"os" "os"
"time" "time"
"strconv" "strconv"
"strings" "strings"
) )
func main() { func main() {
service := ":1200" service := ":1200"
tcpAddr, err := net.ResolveTCPAddr("tcp4", service) tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
checkError(err) checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr) listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err) checkError(err)
for { for {
conn, err := listener.Accept() conn, err := listener.Accept()
if err != nil { if err != nil {
continue continue
}
go handleClient(conn)
} }
go handleClient(conn)
} }
}
func handleClient(conn net.Conn) { func handleClient(conn net.Conn) {
conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) // set 2 minutes timeout conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) // set 2 minutes timeout
request := make([]byte, 128) // set maxium request length to 128B to prevent flood attack request := make([]byte, 128) // set maxium request length to 128B to prevent flood attack
defer conn.Close() // close connection before exit defer conn.Close() // close connection before exit
for { for {
read_len, err := conn.Read(request) read_len, err := conn.Read(request)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
break break
} }
if read_len == 0 { if read_len == 0 {
break // connection already closed by client break // connection already closed by client
@@ -302,15 +302,15 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
} }
request = make([]byte, 128) // clear last read content request = make([]byte, 128) // clear last read content
}
} }
}
func checkError(err error) { func checkError(err error) {
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error()) fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
os.Exit(1) os.Exit(1)
}
} }
}
``` ```
在上面这个例子中，我们使用`conn.Read()`不断读取客户端发来的请求。由于我们需要保持与客户端的长连接，所以不能在读取完一次请求后就关闭连接。由于`conn.SetReadDeadline()`设置了超时，当一定时间内客户端无请求发送，`conn`便会自动关闭，下面的for循环即会因为连接已关闭而跳出。需要注意的是，`request`在创建时需要指定一个最大长度以防止flood attack；每次读取到请求处理完毕后，需要清理request，因为`conn.Read()`会将新读取到的内容append到原内容之后。 在上面这个例子中，我们使用`conn.Read()`不断读取客户端发来的请求。由于我们需要保持与客户端的长连接，所以不能在读取完一次请求后就关闭连接。由于`conn.SetReadDeadline()`设置了超时，当一定时间内客户端无请求发送，`conn`便会自动关闭，下面的for循环即会因为连接已关闭而跳出。需要注意的是，`request`在创建时需要指定一个最大长度以防止flood attack；每次读取到请求处理完毕后，需要清理request，因为`conn.Read()`会将新读取到的内容append到原内容之后。
@@ -319,20 +319,20 @@ Go语言中通过net包中的`DialTCP`函数来建立一个TCP连接，并返回
TCP有很多连接控制函数，我们平常用到比较多的有如下几个函数： TCP有很多连接控制函数，我们平常用到比较多的有如下几个函数：
```Go ```Go
func DialTimeout(net, addr string, timeout time.Duration) (Conn, error) func DialTimeout(net, addr string, timeout time.Duration) (Conn, error)
``` ```
设置建立连接的超时时间，客户端和服务器端都适用，当超过设置时间时，连接自动关闭。 设置建立连接的超时时间，客户端和服务器端都适用，当超过设置时间时，连接自动关闭。
```Go ```Go
func (c *TCPConn) SetReadDeadline(t time.Time) error func (c *TCPConn) SetReadDeadline(t time.Time) error
func (c *TCPConn) SetWriteDeadline(t time.Time) error func (c *TCPConn) SetWriteDeadline(t time.Time) error
``` ```
用来设置写入/读取一个连接的超时时间。当超过设置时间时，连接自动关闭。 用来设置写入/读取一个连接的超时时间。当超过设置时间时，连接自动关闭。
```Go ```Go
func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error
``` ```
设置keepAlive属性，是操作系统层在tcp上没有数据和ACK的时候，会间隔性的发送keepalive包，操作系统可以通过该包来判断一个tcp连接是否已经断开，在windows上默认2个小时没有收到数据和keepalive包的时候人为tcp连接已经断开，这个功能和我们通常在应用层加的心跳包的功能类似。 设置keepAlive属性，是操作系统层在tcp上没有数据和ACK的时候，会间隔性的发送keepalive包，操作系统可以通过该包来判断一个tcp连接是否已经断开，在windows上默认2个小时没有收到数据和keepalive包的时候人为tcp连接已经断开，这个功能和我们通常在应用层加的心跳包的功能类似。
@@ -341,86 +341,86 @@ TCP有很多连接控制函数，我们平常用到比较多的有如下几个
Go语言包中处理UDP Socket和TCP Socket不同的地方就是在服务器端处理多个客户端请求数据包的方式不同,UDP缺少了对客户端连接请求的Accept函数。其他基本几乎一模一样，只有TCP换成了UDP而已。UDP的几个主要函数如下所示： Go语言包中处理UDP Socket和TCP Socket不同的地方就是在服务器端处理多个客户端请求数据包的方式不同,UDP缺少了对客户端连接请求的Accept函数。其他基本几乎一模一样，只有TCP换成了UDP而已。UDP的几个主要函数如下所示：
```Go ```Go
func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error) func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error)
func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err 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 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) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error)
func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error) func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error)
``` ```
一个UDP的客户端代码如下所示,我们可以看到不同的就是TCP换成了UDP而已： 一个UDP的客户端代码如下所示,我们可以看到不同的就是TCP换成了UDP而已：
```Go ```Go
package main package main
import ( import (
"fmt" "fmt"
"net" "net"
"os" "os"
) )
func main() { func main() {
if len(os.Args) != 2 { if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0]) fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])
os.Exit(1) 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) { service := os.Args[1]
if err != nil { udpAddr, err := net.ResolveUDPAddr("udp4", service)
fmt.Fprintf(os.Stderr, "Fatal error ", err.Error()) checkError(err)
os.Exit(1) 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服务器端如何来处理： 我们来看一下UDP服务器端如何来处理：
```Go ```Go
package main package main
import ( import (
"fmt" "fmt"
"net" "net"
"os" "os"
"time" "time"
) )
func main() { func main() {
service := ":1200" service := ":1200"
udpAddr, err := net.ResolveUDPAddr("udp4", service) udpAddr, err := net.ResolveUDPAddr("udp4", service)
checkError(err) checkError(err)
conn, err := net.ListenUDP("udp", udpAddr) conn, err := net.ListenUDP("udp", udpAddr)
checkError(err) checkError(err)
for { for {
handleClient(conn) handleClient(conn)
}
} }
func handleClient(conn *net.UDPConn) { }
var buf [512]byte func handleClient(conn *net.UDPConn) {
_, addr, err := conn.ReadFromUDP(buf[0:]) var buf [512]byte
if err != nil { _, addr, err := conn.ReadFromUDP(buf[0:])
return if err != nil {
} return
daytime := time.Now().String()
conn.WriteToUDP([]byte(daytime), addr)
} }
func checkError(err error) { daytime := time.Now().String()
if err != nil { conn.WriteToUDP([]byte(daytime), addr)
fmt.Fprintf(os.Stderr, "Fatal error ", err.Error()) }
os.Exit(1) func checkError(err error) {
} if err != nil {
fmt.Fprintf(os.Stderr, "Fatal error ", err.Error())
os.Exit(1)
} }
}
``` ```
## 总结 ## 总结