Go语言网络编程实战指南

需积分: 10 65 浏览量更新于2024-07-26 1 收藏 932KB PDF 举报

"《Go语言网络编程》" 本书是一本关于使用谷歌的Go编程语言（golang）构建网络应用程序的电子书。它已更新至覆盖Go 1版本，并且随着Go语言的持续发展，预计将引入更多包。以下是本书的主要章节概览： 1. **架构**：这部分可能涵盖Go语言的基本设计原则、并发模型以及如何利用Go的结构来构建可扩展的网络应用。 2. **Go语言概述**：介绍Go语言的基础语法、类型系统、内存管理以及与其他编程语言的不同之处。 3. **套接字级编程**：深入讲解如何在Go中进行低级别网络通信，包括TCP、UDP等协议的使用。 4. **数据序列化**：探讨如何在Go中将数据转换为可传输的格式，如JSON、protobuf等。 5. **应用层协议**：介绍HTTP、FTP、SMTP等常见网络协议的实现，以及如何在Go中创建自定义协议。 6. **字符集和编码管理**：讨论字符编码（如UTF-8）在Go中的处理，以及如何进行多语言支持。 7. **安全**：讲解网络编程中的安全问题，包括加密、认证和授权机制。 8. **HTTP**：详细阐述Go语言对HTTP协议的支持，包括编写HTTP服务器和客户端。 9. **模板**：介绍Go中的文本和HTML模板，用于生成动态内容。 10. **完整的Web服务器**：提供一个完整的Web服务器示例，展示如何使用Go构建实际的网络服务。 11. **HTML**：讲解如何在Go中处理和生成HTML文档。 12. **XML**：介绍Go对XML的支持，包括解析和生成XML数据。 13. **远程过程调用（RPC）**：探讨如何使用Go实现跨网络的函数调用。 14. **网络通道**：介绍Go特有的并发机制，如goroutines和channels，以及它们在网络编程中的应用。 15. **WebSocket**：讲解如何在Go中实现WebSocket协议，以实现实时双向通信。本书的作者是Jan Newmarch，他鼓励读者通过Flattr或PayPal进行捐赠。书中内容经过多次修订和测试，确保与Go的最新版本兼容。这本书是Go语言网络编程的重要资源，无论是初学者还是有经验的开发者，都能从中获得有价值的见解和实践指导。通过学习这本书，读者将能够熟练地利用Go语言的强大功能构建高效、可靠的网络应用程序。

A program to illustrate this is

/* 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)

}

If this is compiled to the executable IP then it can run for example as

IP 127.0.0.1

with response

The address is 127.0.0.1

or as

IP 0:0:0:0:0:0:0:1

with response

The address is ::1

The type IPmask

In order to handle masking operations, there is the type

type IPMask []byte

There is a function to create a mask from a 4-byte IPv4 address

func IPv4Mask(a, b, c, d byte) IPMask

Alternatively, there is a method of IP which returns the default mask

func (ip IP) DefaultMask() IPMask

Note that the string form of a mask is a hex number such as ffff0000 for a mask of 255.255.0.0.

A mask can then be used by a method of an IP address to find the network for that IP address

func (ip IP) Mask(mask IPMask) IP

An example of the use of this is the following program:

/* Mask

Sockets

Version 1.0 Page 16©Jan Newmarch - Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

os.Exit(0)

}

Running ResolveIP www.google.com returns

Resolved address is 66.102.11.104

Host lookup

The function ResolveIPAddr will perform a DNS lookup on a hostname, and return a single IP address. However, hosts may have

multiple IP addresses, usually from multiple network interface cards. They may also have multiple host names, acting as aliases.

func LookupHost(name string) (cname string, addrs []string, err os.Error)

One of these addresses will be labelled as the "canonical" host name. If you wish to find the canonical name, use func

LookupCNAME(name string) (cname string, err os.Error)

This is shown in the following program

/* LookupHost

package main

import (

"net"

"os"

"fmt"

)

func main() {

if len(os.Args) != 2 {

fmt.Fprintf(os.Stderr, "Usage: %s hostname\n", os.Args[0])

os.Exit(1)

}

name := os.Args[1]

addrs, err := net.LookupHost(name)

if err != nil {

fmt.Println("Error: ", err.Error())

os.Exit(2)

}

for _, s := range addrs {

fmt.Println(s)

}

os.Exit(0)

}

Note that this function returns strings, not IPAddress values.

3.5 Services

Services run on host machines. They are typically long lived and are designed to wait for requests and respond to them. There are

many types of services, and there are many ways in which they can offer their services to clients. The internet world bases many of

these services on two methods of communication, TCP and UDP, although there are other communication protocols such as

SCTP waiting in the wings to take over. Many other types of service, such as peer-to-peer, remote procedure calls,

communicating agents, and many others are built on top of TCP and UDP.

Ports

Services live on host machines. The IP address will locate the host. But on each computer may be many services, and a simple

way is needed to distinguish between them. The method used by TCP, UDP, SCTP and others is to use a port number. This is an

unsigned integer beween 1 and 65,535 and each service will associate itself with one or more of these port numbers.

There are many "standard" ports. Telnet usually uses port 23 with the TCP protocol. DNS uses port 53, either with TCP or with

UDP. FTP uses ports 21 and 20, one for commands, the other for data transfer. HTTP usually uses port 80, but it often uses

ports 8000, 8080 and 8088, all with TCP. The X Window System often takes ports 6000-6007, both on TCP and UDP.

On a Unix system, the commonly used ports are listed in the file /etc/services. Go has a function to interrogate this file

func LookupPort(network, service string) (port int, err os.Error)

The network argument is a string such as "tcp" or "udp", while the service is a string such as "telnet" or "domain" (for DNS).

Sockets

Version 1.0 Page 18©Jan Newmarch - Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

A program using this is

/* LookupPort

package main

import (

"net"

"os"

"fmt"

)

func main() {

if len(os.Args) != 3 {

fmt.Fprintf(os.Stderr,

"Usage: %s network-type service\n",

os.Args[0])

os.Exit(1)

}

networkType := os.Args[1]

service := os.Args[2]

port, err := net.LookupPort(networkType, service)

if err != nil {

fmt.Println("Error: ", err.Error())

os.Exit(2)

}

fmt.Println("Service port ", port)

os.Exit(0)

}

For example, running LookupPort tcp telnet prints Service port: 23

The type TCPAddr

The type TCPAddr is a structure containing an IP and a port:

type TCPAddr struct {

IP IP

Port int

}

The function to create a TCPAddr is ResolveTCPAddr

func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error)

where net is one of "tcp", "tcp4" or "tcp6" and the addr is a string composed of a host name or IP address, followed by the port

number after a ":", such as "www.google.com:80" or '127.0.0.1:22". if the address is an IPv6 address, which already has colons in

it, then the host part must be enclosed in square brackets, such as "[::1]:23". Another special case is often used for servers, where

the host address is zero, so that the TCP address is really just the port name, as in ":80" for an HTTP server.

3.6 TCP Sockets

When you know how to reach a service via its network and port IDs, what then? If you are a client you need an API that will allow

you to connect to a service and then to send messages to that service and read replies back from the service.

If you are a server, you need to be able to bind to a port and listen at it. When a message comes in you need to be able to read it

and write back to the client.

The net.TCPConn is the Go type which allows full duplex communication between the client and the server. Two major methods of

interest are

func (c *TCPConn) Write(b []byte) (n int, err os.Error)

func (c *TCPConn) Read(b []byte) (n int, err os.Error)

A TCPConn is used by both a client and a server to read and write messages.

TCP client

Once a client has established a TCP address for a service, it "dials" the service. If succesful, the dial returns a TCPConn for

communication. The client and the server exchange messages on this. Typically a client writes a request to the server using the

TCPConn, and reads a response from the TCPConn. This continues until either (or both) sides close the connection. A TCP connection

is established by the client using the function

Sockets

func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err os.Error)

where laddr is the local address which is usually set to nil and raddr is the remote address of the service, and the net string is one

of "tcp4", "tcp6" or "tcp" depending on whether you want a TCPv4 connection, a TCPv6 connection or don't care.

A simple example can be provided by a client to a web (HTTP) server. We will deal in substantially more detail with HTTP clients

and servers in a later chapter, but for now we will keep it simple.

One of the possible messages that a client can send is the "HEAD" message. This queries a server for information about the

server and a document on that server. The server returns information, but does not return the document itself. The request sent to

query an HTTP server could be

"HEAD / HTTP/1.0\r\n\r\n"

which asks for information about the root document and the server. A typical response might be

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

We first give the program (GetHeadInfo.go) to establish the connection for a TCP address, send the request string, read and print

the response. Once compiled it can be invoked by e.g.

GetHeadInfo www.google.com:80

The program is

/* GetHeadInfo

package main

import (

"net"

"os"

"fmt"

"io/ioutil"

)

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 := readFully(conn)

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)

}

The first point to note is the almost excessive amount of error checking that is going on. This is normal for networking programs:

the opportunities for failure are substantially greater than for standalone programs. Hardware may fail on the client, the server, or

on any of the routers and switches in the middle; communication may be blocked by a firewall; timeouts may occur due to network

load; the server may crash while the client is talking to it. The following checks are performed:

1. There may be syntax errors in the address specified

2. The attempt to connect to the remote service may fail. For example, the service requested might not be running, or there

Sockets

剩余122页未读，继续阅读

qinglong1983

粉丝: 0
资源: 5

Go语言网络编程实战指南

Go语言网络编程：从入门到安全实践

Go语言网络编程实战：构建与保护网络应用

Beej's Guide to Network Programming：轻松学习网络编程

Network Programming with Go 2017

Network Programming with Go 无水印pdf

Network programming with Go(English)

network-programming-with-go-zh-cn

Network.Programming.with.Go.2021.3

network-programming-go

network-programming-with-go (2).pdf

最新资源