Java Socket编程：TCP/IP Sockets实战指南（第二版）

需积分: 17 198 浏览量更新于2024-07-29 收藏 2.89MB PDF 举报

"TCP/IP Sockets in Java 2nd Edition" 是一本关于Java套接字编程的专业书籍，由Kenneth L. Calvert和Michael J. Donahoo撰写，属于Morgan Kaufmann的实践指南系列。这本书是第二版，旨在帮助开发者深入理解和应用Java中的TCP/IP套接字技术。 TCP/IP是互联网的基础协议，它定义了网络设备如何交换数据。而Socket是TCP/IP协议族中的一个关键概念，它是网络通信中的接口，允许两个应用程序通过网络进行通信。在Java中，套接字API提供了实现客户端-服务器通信的机制。本书详细介绍了如何在Java环境中利用套接字进行网络编程，涵盖了以下关键知识点： 1. **基础概念**：书中首先会讲解TCP/IP协议栈的基本结构，包括网络层次模型、IP地址、端口号以及套接字的工作原理。 2. **Java Socket API**：介绍Java提供的Socket类和ServerSocket类，包括如何创建、连接、监听和关闭套接字，以及相关的异常处理。 3. **客户端编程**：详细阐述如何编写TCP客户端程序，包括建立连接、发送和接收数据，以及断开连接的步骤。 4. **服务器端编程**：解释如何构建多线程服务器以处理多个并发连接，使用ServerSocket进行监听和接受客户端请求。 5. **流与缓冲**：讨论字节流和字符流在套接字通信中的应用，以及如何使用BufferedReader和PrintWriter进行高效的数据传输。 6. **异常处理**：强调在网络编程中处理各种可能的异常情况，如连接中断、超时或数据格式错误。 7. **高级主题**：包括套接字选项的设置，如SO_REUSEADDR和SO_LINGER，以及非阻塞I/O和多路复用I/O模型如NIO（New I/O）。 8. **实例分析**：书中会提供一系列实际的示例代码，帮助读者理解如何将理论知识应用于实际项目中。 9. **网络安全性**：简要探讨Java安全框架，如SSL/TLS协议在套接字通信中的应用，以确保数据的安全传输。 10. **性能优化**：如何通过优化代码和配置提高网络通信的性能，减少延迟并提高吞吐量。通过学习这本书，Java程序员可以掌握构建可靠、高效的网络应用程序所需的技能，无论是开发简单的文件传输应用还是复杂的分布式系统，都能从中受益。对于想要深入理解Java网络编程的开发者来说，这是一本不可多得的参考资料。

chapter 1

Introduction

Today people use computers to make phone calls, to watch TV, to send instant messages

to their friends, to play games with other people, and to buy almost anything you can think

of—from songs to SUVs. The ability for programs to communicate over the Internet makes

all this possible. It’s hard to say how many individual computers are now reachable over the

Internet, but we can safely say that it is growing rapidly; it won’t be long before the number is

in the billions. Moreover, new applications are being developed every day. With the push for

ever increasing bandwidth and access, the impact of the Internet will continue to grow for the

foreseeable future.

How does a program communicate with another program over a network? The goal of

this book is to start you on the road to understanding the answer to that question, in the

context of the Java programming language. The Java language was designed from the start for

use over the Internet. It provides many useful abstractions for implementing programs that

communicate via the application programming interface (API) known as sockets.

Before we delve into the details of sockets, however, it is worth taking a brief look at

the big picture of networks and protocols to see where our code will ﬁt in. Our goal here

is not to teach you how networks and TCP/IP work—many ﬁne texts are available for that

purpose [4, 6, 12, 16, 17]—but rather to introduce some basic concepts and terminology.

1.1 Networks, Packets, and Protocols

A computer network consists of machines interconnected by communication channels. We call

these machines hosts and routers. Hosts are computers that run applications such as your Web

2 Chapter 1: Introduction

browser, your IM agent, or a ﬁle-sharing program. The application programs running on hosts

are the real “users” of the network. Routers are machines whose job is to relay, or forward,

information from one communication channel to another. They may run programs but typically

do not run application programs. For our purposes, a communication channel is a means of

conveying sequences of bytes from one host to another; it may be a wired (e.g., Ethernet), a

wireless (e.g., WiFi), or other connection.

Routers are important simply because it is not practical to connect every host directly

to every other host. Instead, a few hosts connect to a router, which connects to other routers,

and so on to form the network. This arrangement lets each machine get by with a relatively

small number of communication channels; most hosts need only one. Programs that exchange

information over the network, however, do not interact directly with routers and generally

remain blissfully unaware of their existence.

By information we mean sequences of bytes that are constructed and interpreted by pro-

grams. In the context of computer networks, these byte sequences are generally called packets.

A packet contains control information that the network uses to do its job and sometimes also

includes user data. An example is information identifying the packet’s destination. Routers

use such control information to ﬁgure out how to forward each packet.

A protocol is an agreement about the packets exchanged by communicating programs

and what they mean. A protocol tells how packets are structured—for example, where the

destination information is located in the packet and how big it is—as well as how the infor-

mation is to be interpreted. A protocol is usually designed to solve a speciﬁc problem using

given capabilities. For example, the HyperText Transfer Protocol (HTTP) solves the problem of

transferring hypertext objects between servers, where they are stored or generated, and Web

browsers that make them visible and useful to users. Instant messaging protocols solve the

problem of enabling two or more users to exchange brief text messages.

Implementing a useful network requires solving a large number of diﬀerent problems.

To keep things manageable and modular, diﬀerent protocols are designed to solve diﬀerent

sets of problems. TCP/IP is one such collection of solutions, sometimes called a protocol suite.

It happens to be the suite of protocols used in the Internet, but it can be used in stand-alone

private networks as well. Henceforth when we talk about the network, we mean any network

that uses the TCP/IP protocol suite. The main protocols in the TCP/IP suite are the Inter-

net Protocol (IP) [14], the Transmission Control Protocol (TCP) [15], and the User Datagram

Protocol (UDP) [13].

It turns out to be useful to organize protocols into layers; TCP/IP and virtually all other

protocol suites are organized this way. Figure 1.1 shows the relationships among the protocols,

applications, and the sockets API (Application Programming Interface) in the hosts and routers,

as well as the ﬂow of data from one application (using TCP) to another. The boxes labeled TCP,

UDP, and IP represent implementations of those protocols. Such implementations typically

reside in the operating system of a host. Applications access the services provided by UDP and

TCP through the sockets API. The arrow depicts the ﬂow of data from the application, through

the TCP and IP implementations, through the network, and back up through the IP and TCP

implementations at the other end.

1.1 Networks, Packets, and Protocols 3

Channel

(e.g., Ethernet)

Router

Host

Channel

TCPTCP

Application

Socket

UDP

Application

Socket

UDP

Transport

Layer

Network

Layer

Figure 1.1: A TCP/IP network.

In TCP/IP, the bottom layer consists of the underlying communication channels—for

example, Ethernet or dial-up modem connections. Those channels are used by the network

layer, which deals with the problem of forwarding packets toward their destination (i.e., what

routers do). The single network layer protocol in the TCP/IP suite is the Internet Protocol; it

solves the problem of making the sequence of channels and routers between any two hosts

look like a single host-to-host channel.

The Internet Protocol provides a datagram service: every packet is handled and delivered

by the network independently, like letters or parcels sent via the postal system. To make this

work, each IP packet has to contain the address of its destination, just as every package that

you mail is addressed to somebody. (We’ll say more about addresses shortly.) Although most

delivery companies guarantee delivery of a package, IP is only a best-eﬀort protocol: it attempts

to deliver each packet, but it can (and occasionally does) lose, reorder, or duplicate packets in

transit through the network.

The layer above IP is called the transport layer. It oﬀers a choice between two protocols:

TCP and UDP. Each builds on the service provided by IP, but they do so in diﬀerent ways to

provide diﬀerent kinds of transport, which are used by application protocols with diﬀerent

needs. TCP and UDP have one function in common: addressing. Recall that IP delivers packets

to hosts; clearly, a ﬁner granularity of addressing is needed to get a packet to a particular

application program, perhaps one of many using the network on the same host. Both TCP and

UDP use addresses, called port numbers, to identify applications within hosts. TCP and UDP

are called end-to-end transport protocols because they carry data all the way from one program

to another (whereas IP only carries data from one host to another).

TCP is designed to detect and recover from the losses, duplications, and other errors

that may occur in the host-to-host channel provided by IP. TCP provides a reliable byte-stream

channel so that applications do not have to deal with these problems. It is a connection-

oriented protocol: before using it to communicate, two programs must ﬁrst establish a TCP

4 Chapter 1: Introduction

connection, which involves completing an exchange of handshake messages between the TCP

implementations on the two communicating computers. Using TCP is also similar in many ways

to ﬁle input/output (I/O). In fact, a ﬁle that is written by one program and read by another is

a reasonable model of communication over a TCP connection. UDP, on the other hand, does

not attempt to recover from errors experienced by IP; it simply extends the IP best-eﬀort data-

gram service so that it works between application programs instead of between hosts. Thus,

applications that use UDP must be prepared to deal with losses, reordering, and so on.

1.2 About Addresses

When you mail a letter, you provide the address of the recipient in a form that the postal

service can understand. Before you can talk to someone on the phone, you must supply a

phone number to the telephone system. In a similar way, before a program can communicate

with another program, it must tell the network something to identify the other program. In

TCP/IP, it takes two pieces of information to identify a particular program: an Internet address,

used by IP, and a port number, the additional address interpreted by the transport protocol

(TCP or UDP).

Internet addresses are binary numbers. They come in two ﬂavors, corresponding to the

two versions of the Internet Protocol that have been standardized. The most common type is

version 4 (“IPv4,” [14]); the other is version 6 (“IPv6,” [7]), which is just beginning to be deployed.

IPv4 addresses are 32 bits long; because this is only enough to identify about 4 billion distinct

destinations, they are not really big enough for today’s Internet. (That may seem like a lot, but

because of the way they are allocated, many are wasted. More than half of the total address

space has already been allocated.) For that reason, IPv6 was introduced. IPv6 addresses are

128 bits long.

In writing down Internet addresses for human consumption (as opposed to using them

inside programs), diﬀerent conventions are used for the two versions of IP. IPv4 addresses are

conventionally written as a group of four decimal numbers separated by periods (e.g., 10.1.2.3);

this is called the dotted-quad notation. The four numbers in a dotted-quad string represent

the contents of the four bytes of the Internet address—thus, each is a number between 0

and 255.

The sixteen bytes of an IPv6 address, on the other hand, are represented as groups

of hexadecimal digits, separated by colons (e.g., 2000:fdb8:0000:0000:0001:00ab:853c:39a1).

Each group of digits represents two bytes of the address; leading zeros may be omitted, so

the ﬁfth and sixth groups in the foregoing example might be rendered as just :1:ab:. Also, con-

secutive groups that contain only zeros may be omitted altogether (but this can only be done

once in any address). So the example above could be written as 2000:fdb8::1:00ab:853c:39a1.

Technically, each Internet address refers to the connection between a host and an under-

lying communication channel—in other words, a network interface. A host may have several

interfaces; it is not uncommon, for example, for a host to have connections to both wired

1.2 About Addresses 5

(Ethernet) and wireless (WiFi) networks. Because each such network connection belongs to a

single host, an Internet address identiﬁes a host as well as its connection to the network.

However, the converse is not true, because a single host can have multiple interfaces, and each

interface can have multiple addresses. (In fact, the same interface can have both IPv4 and IPv6

addresses.)

The port number in TCP or UDP is always interpreted relative to an Internet address.

Returning to our earlier analogies, a port number corresponds to a room number at a given

street address, say, that of a large building. The postal service uses the street address to get the

letter to a mailbox; whoever empties the mailbox is then responsible for getting the letter to the

proper room within the building. Or consider a company with an internal telephone system:

to speak to an individual in the company, you ﬁrst dial the company’s main phone number to

connect to the internal telephone system and then dial the extension of the particular telephone

of the individual you wish to speak with. In these analogies, the Internet address is the street

address or the company’s main number, whereas the port corresponds to the room number

or telephone extension. Port numbers are 16-bit unsigned binary numbers, so each one is in

the range 1 to 65,535. (0 is reserved.)

In each version of IP, certain special-purpose addresses are deﬁned. One of these that

is worth knowing is the loopback address, which is always assigned to a special loopback

interface, a virtual device that simply echoes transmitted packets right back to the sender.

The loopback interface is very useful for testing because packets sent to that address are

immediately returned back to the destination. Moreover, it is present on every host, and can

be used even when a computer has no other interfaces (i.e., is not connected to the network).

The loopback address for IPv4 is 127.0.0.1;

for IPv6 it is 0:0:0:0:0:0:0:1.

Another group of IPv4 addresses reserved for a special purpose includes those reserved

for “private use.” This group includes all IPv4 addresses that start with 10 or 192.168, as well

as those whose ﬁrst number is 172 and whose second number is between 16 and 31. (There is

no corresponding class for IPv6.) These addresses were originally designated for use in private

networks that are not part of the global Internet. Today they are often used in homes and small

oﬃces that are connected to the Internet through a network address translation (NAT) device.

Such a device acts like a router that translates (rewrites) the addresses and ports in packets as

it forwards them. More precisely, it maps (private address, port) pairs in packets on one of its

interfaces to (public address, port) pairs on the other interface. This enables a small group of

hosts (e.g., those on a home network) to eﬀectively “share” a single IP address. The importance

of these addresses is that they cannot be reached from the global Internet. If you are trying out

the code in this book on a machine that has an address in the private-use class, and you are

trying to communicate with another host that does not have one of these addresses, typically

you will only succeed if the host with the private address initiates communication.

A related class contains the link-local, or “autoconﬁguration” addresses. For IPv4, such

addresses begin with 169.254. For IPv6, any address whose ﬁrst 16-bit chunk starts with FE8

Technically any IPv4 address beginning with 127 should loop back.

剩余192页未读，继续阅读

zbwork000

粉丝: 31
资源: 10

Java Socket编程：TCP/IP Sockets实战指南（第二版）

TCP.IP.Sockets.in.Java.2nd.Edition.pdf (TCP/IP Socket 编程）

TCP.IP.Sockets.in.Java.2nd.Edition

TCPIP.Sockets.in.Java.Practical.Guide.for.Programmers.2nd.Edition

TCPIP Sockets in C 2nd Edition 英文版

TCP IP Sockets in C 2nd Practical Guide for Programmers2009

Linux&TCP/IP

Kali Linux Network Scanning Cookbook - Second Edition [2017]

Java_TCPIP_Socket编程（中+英两本）

计算机网络第六版答案

TCP/IP Sockets in C: 英文版技术解析

最新资源