Go语言网络编程指南：实战应用与最新特性

需积分: 9 20 浏览量更新于2024-07-25 收藏 914KB PDF 举报

"《网络编程与Go》是一本详细介绍如何使用Google的Go编程语言（golang）构建网络应用的电子书，该书于2012年4月27日发布，经过修订以适应Go 1版本。尽管书中并非详尽无遗，因为Go语言还在不断演进，作者Jan Newmarch希望读者能跟随最新发展。本书共分为15个章节，涵盖了网络编程的基础到高级主题。 1. **架构**：介绍网络应用的基本结构和设计原则，帮助读者理解如何组织代码以实现高效、可靠的网络服务。 2. **Go语言概述**：对Go语言进行简要介绍，包括其语法特性、并发支持和内存管理，这对于初次接触Go的读者来说至关重要。 3. **套接字级编程**：讲解如何利用Go的socket编程库进行底层通信，包括套接字创建、连接、数据传输等操作。 4. **数据序列化**：介绍如何在不同组件间高效地交换数据，如JSON、XML等格式的处理。 5. **应用层协议**：探讨HTTP、WebSocket等常用的应用层协议，以及如何在Go中实现它们。 6. **字符集和编码管理**：确保网络通信中的文本数据正确解析和发送，涉及到编码转换和字符集选择。 7. **安全**：讨论网络安全问题，包括SSL/TLS加密、身份验证和数据保护措施。 8. **HTTP**：深入讲解如何用Go编写HTTP服务器和客户端，包括RESTful API的设计和实现。 9. **模板引擎**：介绍Go的模板系统，如何构建动态网页和渲染数据。 10. **完整的Web服务器示例**：提供一个基于Go的完整Web服务器开发案例，展示实际应用中的架构和代码实现。 11. **HTML**：与模板结合，讲解如何处理和生成HTML响应。 12. **XML**：处理XML数据的处理方法，包括解析和生成XML文档。 13. **远程过程调用（RPC）**：介绍如何利用Go实现跨进程或跨机器的函数调用，支持分布式系统。 14. **网络通道（Channels）**：Go的并发特性之一，通过通道进行线程安全的消息传递。 15. **WebSocket**：探讨Go对WebSocket的支持，实现实时通信的应用场景。随着Go语言版本的更新，书中也相应地更新了模板章节和Websocket部分，确保内容与时俱进。作者鼓励读者反馈和参与，可以通过Flattr捐款或通过PayPal支持，以推动后续版本的改进。每一版的更新都伴随着代码的测试和修订，确保提供的代码质量。《网络编程与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 0.5 Page 16 ©Jan Newmarch

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 0.5 Page 18 ©Jan Newmarch

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页未读，继续阅读

csdddn

粉丝: 12
资源: 208

Go语言网络编程指南：实战应用与最新特性

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

Python Network Programming Cookbook, 2nd Edition - 2017

[Go语言入门（含源码）] The Way to Go (with source code)

Microsoft Outlook 2007 Programming: Jumpstart for Power Users and Administrators Sample chapters:Chapter 1 - What You Can Do with Outlook 2007 (PDF, 794kb)

最新资源