Java套接字编程实战指南

需积分: 9 113 浏览量更新于2024-07-24 收藏 2.9MB PDF 举报

"TCP/IP Sockets in Java: Practical Guide for Programmers, Second Edition" 是一本专为Java程序员设计的深入指南，由Kenneth L. Calvert和Michael J. Donahoo撰写，属于Morgan Kaufmann Practical Guides系列。这本书专注于教授如何在Java环境中使用TCP/IP套接字进行网络编程。在本书中，读者将了解到以下关键知识点： 1. **Java Socket基础知识**：Java Socket是Java API的一部分，允许在网络间进行双向通信。书里会详细介绍Socket类和ServerSocket类的使用，包括它们的构造方法、方法和属性，以及如何创建和接受连接。 2. **TCP协议**：传输控制协议（TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议。书中会阐述TCP的特性，如三次握手建立连接、数据确认、流量控制和拥塞控制等。 3. **IP协议**：互联网协议（IP）是网络层的主要协议，负责将数据包从源主机传输到目的主机。书中会讲解IP地址、子网掩码、默认网关等概念，以及IP数据报的工作原理。 4. **网络编程模型**：书中可能会涵盖客户端-服务器模型，解释如何编写客户端程序来发起请求，以及如何构建服务器端程序来接收和处理这些请求。 5. **多线程编程**：由于网络编程通常涉及并发处理多个连接，因此书中会涵盖Java中的线程和同步机制，如何创建和管理线程，以及避免线程安全问题。 6. **异常处理**：网络通信中常遇到各种异常，如连接失败、超时等。作者会教读者如何有效地捕获和处理这些异常。 7. **数据序列化与反序列化**：在网络通信中，数据通常需要被序列化成字节流进行传输。书里会介绍Java的序列化机制，以及如何处理不同数据类型的数据交换。 8. **高级主题**：可能还包括UDP套接字（User Datagram Protocol）、多路复用技术如IO多路复用（Selector）、NIO（New IO）框架，以及套接字选项和性能调优策略。 9. **实例分析**：书中很可能会提供实际的代码示例，帮助读者理解如何在实际项目中应用这些概念，从而提升编程技能。 10. **最佳实践**：作者可能会分享一些网络编程的最佳实践，帮助读者写出高效、健壮和可维护的代码。通过阅读此书，Java程序员可以系统地学习如何利用Java的Socket API进行网络编程，无论是开发简单的通信应用还是构建复杂的多层分布式系统，都将受益匪浅。

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

L_BACK

粉丝: 0
资源: 1

Java套接字编程实战指南

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

TCP.IP.Sockets.In.C.Practical.Guide.For.Programmer_tcp/ip c语言

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

TCPIP.Sockets.in.Java.Second.Edition

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

TCP-IP Sockets in Java. Practical Guide for Programmers

TCPIP Sockets in Java Practical Guide for Programmers

tcp-ip sockets in c practical guide for programmers.pdf

TCP IP Sockets in C 2nd Practical Guide for Programmers2009

Unix.Network.Programming.Volume.1.3rd.Ed.The.Sockets.Networking.Api.chm

最新资源