Java网络编程实战：TCP/IP Sockets指南

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

"TCP/IP Sockets in Java: Practical Guide for Programmers, Second Edition" by Kenneth L. Calvert and Michael J. Donahoo, published in 2008 as part of The Morgan Kaufmann Practical Guides Series, is a definitive resource for learning Java network development. 这本书是Java网络编程的经典之作，特别针对TCP/IP套接字编程提供了实用的指导。TCP/IP套接字是网络通信的基础，它们允许程序通过网络发送和接收数据。Java中的Socket API提供了对这些功能的访问，使得开发者能够构建可伸缩、可靠的网络应用程序。在本书中，作者深入浅出地介绍了以下关键知识点： 1. **基础概念**：首先，书中会讲解网络通信的基本原理，包括TCP/IP协议栈、端口号、IP地址以及套接字的工作机制。 2. **Java Socket API**：详细阐述了Java提供的Socket和ServerSocket类，以及如何使用它们创建客户端和服务器端的连接。还会讨论InputStream和OutputStream的使用，以实现数据的双向传输。 3. **异步I/O**：介绍Java NIO（非阻塞I/O）框架，它提供了更高效的数据处理方式，适合高并发场景。 4. **多线程编程**：由于网络编程往往涉及并发操作，书中会讨论如何使用Java的Thread和ExecutorService来管理并发任务。 5. **异常处理**：在进行网络通信时，错误处理是至关重要的。书中会展示如何正确地捕获和处理网络相关的异常。 6. **网络安全**：涵盖SSL/TLS协议，用于加密和安全的网络通信，以及如何在Java中配置和使用它们。 7. **实战示例**：书中包含丰富的示例代码，涵盖了各种常见应用场景，如聊天应用、文件传输等，帮助读者将理论知识转化为实际技能。 8. **高级主题**：如套接字选项、性能调优、连接管理和广播套接字等，这些都是进阶网络编程的重要内容。 9. **JDBC与网络数据库**：虽然标题没有直接提及，但鉴于作者还编写了《JDBC: Practical Guide for Java Programmers》，可以推测书中可能也涵盖了如何通过Java的Socket进行数据库远程访问。 10. **其他技术结合**：可能还会讨论如何将Socket编程与其他Java技术如JSP、Servlets、Struts框架等结合使用，以构建完整的Web应用。这本书是Java程序员深入理解并掌握TCP/IP套接字编程的理想教材，无论你是初学者还是经验丰富的开发者，都能从中获得宝贵的指导和启发。

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

claymore37927

粉丝: 0
资源: 1

Java网络编程实战：TCP/IP Sockets指南

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

TCPIP.Sockets.in.Java.Second.Edition

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

TCPIP Sockets in Java Practical Guide for Programmers

TCPIP Sockets in C#

tcp ip programing in c

UNIX网络编程第三版英文+TCP/IP中文版+sock in C

Java TCP/IP Sockets 实战指南

Java TCP/IP Sockets实战指南：第二版核心概念解析

C# TCP/IP Sockets实战指南

最新资源