Java Socket编程实践指南：网络通信与多任务处理

需积分: 9 95 浏览量更新于2024-07-23 1 收藏 2.21MB PDF 举报

Java Socket编程是计算机网络编程领域的一个核心概念，它是Java语言实现客户端与服务器之间通信的基础机制。在《TCP/IP Sockets in Java: Practical Guide for Programmers, Second Edition》这本书中，作者Kenneth L. Calvert 和 Michael J. Donahoo对这一技术进行了深入探讨。本书详细介绍了如何利用Java API（如java.net包）来构建TCP/IP套接字，这是一种可靠的、面向连接的通信协议，适用于各种网络应用程序，如网页服务器、聊天应用和游戏服务器等。 TCP/IP套接字编程涉及的主要知识点包括： 1. **套接字基础**：讲解套接字的创建、连接、监听、关闭以及数据的发送和接收等基本操作。Java的Socket类和ServerSocket类是实现这些功能的关键。 2. **多任务处理**：在并发环境中，如何使用线程或者NIO（New I/O）API来管理多个客户端连接，确保高效、稳定的通信服务。 3. **网络编程模型**：理解TCP/IP协议栈的工作原理，包括三次握手、数据包传输、错误检测和重传机制。 4. **安全性和性能优化**：包括加密（如SSL/TLS）的应用，以及如何通过优化套接字设置提高性能，如缓冲区大小、超时设置等。 5. **异常处理**：在实际开发中，如何捕获并处理可能遇到的网络异常，如SocketTimeoutException、IOException等。 6. **示例代码和实战项目**：书中提供了丰富的实例代码，帮助读者理解和实践Socket编程，从简单的Echo服务器到复杂的分布式系统架构。除了Java Socket编程，该系列还包括其他实用的编程指南，如SQL、C#、PHP、C#的TCP/IP Sockets、Java Cryptography Extensions、JSP、JSTL、Java本身以及JDBC等，这些都是IT开发者必备的技能集。通过这个系列，读者可以从不同的角度掌握和提升自己的编程能力，适应不同场景下的软件开发需求。《TCP/IP Sockets in 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页未读，继续阅读

fwgfz2000

粉丝: 1
资源: 4

Java Socket编程实践指南：网络通信与多任务处理

java socket编程

Java socket编程实现两台主机间的通信

java socket 编程

Java Socket 编程

java Socket 编程

Java socket 编程

Java socket编程

混合场景下大规模 GPU 集群构建与实践.pdf

29 螺栓组联接成本优化设计.rar

走向现代化数据分析架构：趋势与挑战.pdf

最新资源