Java网络编程第四版：轻松掌握网络应用

需积分: 10 30 浏览量更新于2024-07-18 收藏 8.05MB PDF 举报

《Java网络编程第四版》是一本由Elliotte Rusty Harold所著的专业IT技术书籍，针对Java语言在网络编程领域的卓越应用进行了深入剖析。自Java诞生以来，其在业界的影响力迅速增长，尤其是在互联网飞速发展的背景下，许多初学者可能会感到网络编程在Java中仍然相对复杂。然而，实际上，利用Java的核心API，编写网络程序可以变得相当简单，这本书将揭示这一过程。该书适合有Unix、Windows或Macintosh环境网络编程经验的读者，他们将惊讶于在Java中实现类似功能的便捷性。书中涵盖了众多实用的主题，如： 1. **HTTP协议下的Web浏览**：Java提供了方便的接口来处理HTTP请求，使得开发Web应用程序更加高效。 2. **多线程服务器设计**：Java的并发编程模型，如NIO（Non-blocking I/O），使得构建高性能服务器变得简单，能够处理大量并发连接。 3. **安全通信**：通过Java的加密库，可以轻松实现数据的保密性、认证和消息完整性，确保通信的安全性。 4. **GUI客户端开发**：为网络服务设计用户界面，使得交互式网络体验更加友好。 5. **数据提交与服务器端程序交互**：Java的Socket API和相关的类库，便于客户端与服务器进行数据交换。 6. **DNS查询**：利用Java处理域名解析，查找主机地址。 7. **匿名FTP文件下载**：展示了如何使用Java进行文件下载，包括基本的FTP操作。 8. **底层网络通信**：通过套接字编程，开发者可以触及到更底层的网络通信机制。 9. **网络广播（Multicast）**：利用Java的多播功能，实现向网络中的所有主机发送数据。《Java网络编程第四版》于2013年发布，强调了其对最新版本Java API的兼容和支持，包括NIO等现代网络编程技术。此外，本书还提供了详细的示例代码和实用的技巧，旨在帮助读者快速掌握并充分利用Java的网络编程能力。无论你是网络编程的初学者还是经验丰富的开发人员，这本书都是提升Java网络编程技能的宝贵资源。

you to start using Java as a platform for serious network programming. To do so, this

book provides a general background in network fundamentals, as well as detailed dis‐

cussions of Java’s facilities for writing network programs. You’ll learn how to write Java

programs that share data across the Internet for games, collaboration, software updates,

file transfer, and more. You’ll also get a behind-the-scenes look at HTTP, SMTP,

TCP/IP, and the other protocols that support the Internet and the Web. When you finish

this book, you’ll have the knowledge and the tools to create the next generation of

software that takes full advantage of the Internet.

About the Fourth Edition

In 1996, in the first edition of this book’s opening chapter, I wrote extensively about the

sort of dynamic, distributed network applications I thought Java would make possible.

One of the most exciting parts of writing subsequent editions has been seeing virtually

all of the applications I foretold come to pass. Programmers are using Java to query

database servers, monitor web pages, control telescopes, manage multiplayer games,

and more, all by using Java’s native ability to access the Internet. Java in general and

network programming in Java in particular has moved well beyond the hype stage and

into the realm of real, working applications.

This book has come a long way, too. The fourth edition focuses even more heavily on

HTTP and REST. HTTP has gone from being one of many network protocols to almost

the network protocol. As you’ll see, it is often the protocol on which other protocols are

built, forming its own layer in the network stack.

There have been lots of other small changes and updates throughout the java.net and

supporting packages in Java 6, 7, and 8, and these are covered here as well. New classes

addressed in this edition include CookieManager, CookiePolicy, CookieStore,

HttpCookie, SwingWorker, Executor, ExecutorService, AsynchronousSocketChan

nel, AsynchronousServerSocketChannel, and more. Many other methods have been

added to existing classes in the last three releases of Java, and these are discussed in the

relevant chapters. I’ve also rewritten large parts of the book to reflect the ever-changing

fashions in Java programming in general and network programming in particular. I

hope you’ll find this fourth edition an even stronger, longer-lived, more accurate, and

more enjoyable tutorial and reference to network programming in Java than the pre‐

vious one.

Organization of the Book

Chapter 1, Basic Network Concepts, explains in detail what a programmer needs to know

about how the networks and the Internet work. It covers the protocols that underlie the

Internet, such as TCP/IP and UDP/IP.

xiv | Preface

www.it-ebooks.info

The next two chapters throw some light on two parts of Java programming that are

critical to almost all network programs but are often misunderstood and misused: I/O

and threading. Chapter 2, Streams, explores Java’s classic I/O which—despite the new

I/O APIs—isn’t going away any time soon and is still the preferred means of handling

input and output in most client applications. Understanding how Java handles I/O in

the general case is a prerequisite for understanding the special case of how Java handles

network I/O. Chapter 3, Threads, explores multithreading and synchronization, with a

special emphasis on how they can be used for asynchronous I/O and network servers.

Experienced Java programmers may be able to skim or skip these two chapters. However,

Chapter 4, Internet Addresses, is essential reading for everyone. It shows how Java pro‐

grams interact with the Domain Name System through the InetAddress class, the one

class that’s needed by essentially all network programs. Once you’ve finished this chap‐

ter, it’s possible to jump around in the book as your interests and needs dictate.

Chapter 5, URLs and URIs, explores Java’s URL class, a powerful abstraction for down‐

loading information and files from network servers of many kinds. The URL class enables

you to connect to and download files and documents from a network server without

concerning yourself with the details of the protocol the server speaks. It lets you connect

to an FTP server using the same code you use to talk to an HTTP server or to read a file

on the local hard disk. You’ll also learn about the newer URI class, a more standards-

conformant alternative for identifying but not retrieving resources.

Chapter 6, HTTP, delves deeper into the HTTP protocol specifically. Topics covered

include REST, HTTP headers, and cookies. Chapter 7, URLConnections, shows you how

to use the URLConnection and HttpURLConnection classes not just to download data

from web servers, but to upload documents and configure connections.

Chapter 8 through Chapter 10 discuss Java’s low-level socket classes for network access.

Chapter 8, Sockets for Clients, introduces the Java sockets API and the Socket class in

particular. It shows you how to write network clients that interact with TCP servers of

all kinds including whois, dict, and HTTP. Chapter 9, Sockets for Servers, shows you

how to use the ServerSocket class to write servers for these and other protocols. Finally,

Chapter 10, Secure Sockets, shows you how to protect your client-server communica‐

tions using the Secure Sockets Layer (SSL) and the Java Secure Sockets Extension (JSSE).

Chapter 11, Nonblocking I/O, introduces the new I/O APIs specifically designed for

network servers. These APIs enable a program to figure out whether a connection is

ready before it tries to read from or write to the socket. This allows a single thread to

manage many different connections simultaneously, thereby placing much less load on

the virtual machine. The new I/O APIs don’t help much for small servers or clients that

don’t open many simultaneous connections, but they may provide performance boosts

for high-volume servers that want to transmit as much data as the network can handle

as fast as the network can deliver it.

Preface | xv

www.it-ebooks.info

Chapter 12, UDP, introduces the User Datagram Protocol (UDP) and the associated

DatagramPacket and DatagramSocket classes that provide fast, unreliable communi‐

cation. Finally, Chapter 13, IP Multicast, shows you how to use UDP to communicate

with multiple hosts at the same time.

Who You Are

This book assumes you are comfortable with the Java language and programming en‐

vironment, in addition to object-oriented programming in general. This book does not

attempt to be a basic language tutorial. You should be thoroughly familiar with the

syntax of Java. You should have written simple applications. It also wouldn’t hurt if you’re

familiar with basic Swing programming, though that’s not required aside from a few

examples. When you encounter a topic that requires a deeper understanding for net‐

work programming than is customary—for instance, threads and streams—I’ll cover

that topic as well, at least briefly.

However, this book doesn’t assume that you have prior experience with network pro‐

gramming. You should find it a complete introduction to networking concepts and

network application development. I don’t assume that you have a few thousand net‐

working acronyms (TCP, UDP, SMTP, etc.) at the tip of your tongue. You’ll learn what

you need to know about these here.

Java Versions

Java’s network classes have changed a lot more slowly since Java 1.0 than other parts of

the core API. In comparison to the AWT or I/O, there have been almost no changes and

only a few additions. Of course, all network programs make extensive use of the I/O

classes and some make heavy use of GUIs. This book is written with the assumption

that you are coding with at least Java 5.0. In general, I use Java 5 features like generics

and the enhanced for loop freely without further explanation.

For network programming purposes, the distinction between Java 5 and Java 6 is not

large. Most examples look identical in the two versions. When a particular method or

class is new in Java 6, 7, or 8, it is noted by a comment following its declaration like this:

public void setFixedLengthStreamingMode(long contentLength) // Java 7

Java 7 is a bit more of a stretch. I have not shied away from using features introduced

in Java 7 where they seemed especially useful or convenient—for instance, try-with-

resources and multicatch are both very helpful when trying to fit examples into the

limited space available in a printed book—but I have been careful to point out my use

of such features.

Overall, though, Java’s networking API has been relatively stable since Java 1.0. Very

little of the post-1.0 networking API has ever been deprecated, and additions have been

xvi | Preface

www.it-ebooks.info

relatively minor. You shouldn’t have any trouble using this book after Java 8 is released.

New APIs, however, have been somewhat more frequent in the supporting classes, par‐

ticularly I/O, which has undergone three major revisions since Java 1.0.

About the Examples

Most methods and classes described in this book are illustrated with at least one com‐

plete working program, simple though it may be. In my experience, a complete working

program is essential to showing the proper use of a method. Without a program, it is

too easy to drop into jargon or to gloss over points about which the author may be

unclear in his own mind. The Java API documentation itself often suffers from exces‐

sively terse descriptions of the method calls. In this book, I have tried to err on the side

of providing too much explication rather than too little. If a point is obvious to you, feel

free to skip over it. You do not need to type in and run every example in this book; but

if a particular method does give you trouble, you should have at least one working

example.

Each chapter includes at least one (and often several) more complex programs that

demonstrate the classes and methods of that chapter in a more realistic setting. These

often rely on Java features not discussed in this book. Indeed, in many of the programs,

the networking components are only a small fraction of the source code and often the

least difficult parts. Nonetheless, none of these programs could be written as easily in

languages that didn’t give networking the central position it occupies in Java. The ap‐

parent simplicity of the networked sections of the code reflects the extent to which

networking has been made a core feature of Java, and not any triviality of the program

itself. All example programs presented in this book are available online, often with

corrections and additions. You can download the source code from http://www.cafeau

lait.org/books/jnp4/.

I have tested all the examples on Linux and many on Windows and Mac OS X. Most of

the examples given here should work on other platforms and with other compilers and

virtual machines that support Java 5 or later. The most common reasons an example

may not compile with Java 5 or 6 are try-with-resources and multicatch. These examples

can easily be rewritten to support earlier Java versions at the cost of increased verbosity.

I do feel a little guilty about a couple of compromises necessitated by the needs of space

in a printed book. First, I rarely check preconditions. Most methods assume they are

passed good data, and dispense with null checks and similar principles of good code

hygiene. Furthermore, I have reduced the indentation to two characters per block and

four characters per continuation line, as opposed to the Java standard of four and eight,

respectively. I hope these flaws will not be too distracting. On the positive side, these

compromises have aided me in making this edition considerably shorter (by several

hundred pages) than the previous edition.

Preface | xvii

www.it-ebooks.info

剩余501页未读，继续阅读

defning

粉丝: 1
资源: 16

Java网络编程第四版：轻松掌握网络应用

( Java Network Programming 4th Edition

Java Network Programming 4th Edition

《Learning.Network.Programming.with.Java》高清完整PDF版

java网络编程第4版源码java network programming 4th edition source code

Java网络编程（第四版） [Java network programming, forth edition]

Linux in a Nutshell 6th edition pdf

A Practical Guide to Linux Commands, Editors, and Shell Programming, 4th Edition

Programming+Python,+4th+Edition(2/2)

Programming+Python,+4th+Edition(1/2)

Learning Cocoa with Objective-C, 4th Edition

最新资源