使用Go进行网络编程实战指南

5星 · 超过95%的资源需积分: 10 191 浏览量更新于2024-07-27 收藏 932KB PDF 举报

"《Network Programming with Go》是一本关于使用Google的Go编程语言（golang）构建网络应用程序的电子书。该书已更新至覆盖Go 1版本，并且随着Go的不断发展，预计会引入更多包。书中涵盖了网络编程的基础到高级主题，包括架构、Go语言概述、套接字级编程、数据序列化、应用层协议、字符集和编码管理、安全、HTTP、模板、完整的Web服务器、HTML、XML、远程过程调用、网络通道和WebSocket等内容。" 本书首先介绍了Go语言的架构，帮助读者理解Go语言的设计理念和运行机制，这对于理解和编写高效的网络程序至关重要。Go语言的并发模型，如goroutines和channels，使得处理大量并发连接变得轻松。接着，书中详细阐述了Go语言的基础知识，包括语法、类型系统、错误处理以及标准库的使用，这些都是进行网络编程的基础。此外，套接字级编程部分详细讲解了如何在Go中进行低级别的网络通信，如TCP、UDP等协议的使用。数据序列化章节则涉及如何将数据转换为可以在网络上传输的格式，如JSON、XML等。这部分内容对于实现跨平台的数据交换和存储非常关键。同时，书中也讨论了如何处理不同字符集和编码，这对于处理多语言或国际化内容的网络应用尤为重要。安全章节涵盖了网络编程中的安全实践，如加密、身份验证和授权，确保了应用程序的安全性。HTTP章节深入解析了HTTP协议，包括请求和响应的工作流程，以及如何使用Go来构建HTTP服务器和客户端。模板章节讲解了如何使用Go的模板库创建动态网页内容，而Web服务器章节则展示了一个完整的Web服务器实现，从基础的HTTP路由到错误处理和中间件的使用。进一步，书中还探讨了HTML和XML的处理，这对于构建Web应用来说是不可或缺的部分。远程过程调用（RPC）章节介绍了如何在分布式系统中调用远程函数，而网络通道章节则涉及Go的并发特性在处理网络通信中的应用。最后，WebSocket章节讲解了如何在Go中实现WebSocket协议，用于建立持久化的双向通信通道，适用于实时应用如聊天室、游戏和数据流传输。《Network Programming with 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页未读，继续阅读

atom8473

粉丝: 0
资源: 3

使用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)

最新资源