Java网络编程基础：第3版精华解读

需积分: 7 195 浏览量更新于2024-07-18 收藏 7.09MB PDF 举报

"Java网络编程(第3版,2004)" 是一本由Elliotte Rusty Harold编写的书籍，专注于Java平台上的网络编程技术。该版本是2004年的高清文字版，带有书签，方便读者查阅和复制内容。这本书与O'Reilly出版社的其他Java相关资源相辅相成，包括样本章节、代码示例以及企业Java开发者所需的各种信息。在Java网络编程领域，本书可能涵盖了以下关键知识点： 1. **Java套接字(Socket)**：Java中的Socket类和ServerSocket类是进行网络通信的基础，它们提供了TCP/IP连接的建立和数据传输的方法。 2. **输入/输出流(I/O Stream)**：Java的IO流体系结构用于在网络编程中读取和写入数据。包括字节流、字符流、对象流以及缓冲流等。 3. **多线程(Thread)**：网络编程中经常涉及并发处理，因此理解如何创建和管理线程，以及线程同步和通信机制（如synchronized关键字、wait()和notify()方法）至关重要。 4. **UDP协议与DatagramSocket**：除了TCP，Java也支持使用UDP协议进行无连接的网络通信，DatagramSocket类用于发送和接收数据报包。 5. **网络协议处理**：如HTTP、FTP、SMTP等协议，Java提供了相关的API（如java.net.HttpURLConnection）来处理这些协议，以便开发网络应用程序。 6. **异常处理**：网络编程中，正确处理IOException和其他相关异常是保证程序稳定性的关键。 7. **网络安全**：Java提供了一系列的安全机制，如SSL/TLS用于加密通信，以及对证书和信任管理的理解。 8. **NIO（非阻塞I/O）**：Java的非阻塞I/O API，自Java 1.4引入，可以提高高并发场景下的性能，例如使用Selector和Channel。 9. **Java Naming and Directory Interface (JNDI)**：对于企业级应用，JNDI允许查找和访问分布式环境中的资源和服务。 10. **Java服务器页面(JSP)** 和 **Servlet**：对于Web开发，JSP和Servlet是构建动态网站的重要工具，它们与Java网络编程密切相关。此外，O'Reilly出版社还提供了其他与Java相关的资源，如《EnterpriseJavaBeans™》、《Java™andXML》、《Java™Cookbook™》等，可以帮助读者深入学习和实践Java技术。O'Reilly还主办了各种技术会议，为开发者提供了交流和学习的平台。Safari Bookshelf在线参考图书馆提供了丰富的技术书籍资源，订阅者可以搜索并获取数千本书籍中的答案和解决方案。通过这本书，读者可以系统地学习Java网络编程的各个方面，从而能够构建高效、安全且可靠的网络应用程序。

This is the Title of the Book, eMatter Edition

xiv

Preface

Chapter 7, URLs and URIs, explores Java’s

URL

class, a powerful abstraction for

downloading 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.

Once you’ve got an HTML file from a server, you’re going to want to do something

with it. Parsing and rendering HTML is one of the most difficult challenges network

programmers can face. Chapter 8, HTML in Swing, introduces some little known

classes for parsing and rendering HTML documents that take this burden off your

shoulders and put it on Sun’s.

Figure P-1. Chapter prerequisites

Chapter 1

Why Networked Java?

Chapter 2

Basic Network Concepts

Chapter 3

Basic Web Concepts

Chapter 4

Streams

Chapter 9

Sockets for Clients

Chapter 6

Looking Up Internet Addresses

Chapter 7

URLs and URIs

Chapter 10

Sockets for Servers

Chapter 11

Secure Sockets

Chapter 18

Remote Method Invocation

Chapter 19

The Java Mail API

Chapter 5

Threads

Chapter 15

URLConnections

Chapter 8

HTML in Swing

Chapter 12

Non-Blocking I/O

Chapter 13

UDP Datagrams and Sockets

Chapter 14

Multicast Sockets

Chapter 16

Protocol Handlers

Chapter 17

Content Handlers

This is the Title of the Book, eMatter Edition

Preface

Chapters 9 through 11 discuss Java’s low-level socket classes for network access.

Chapter 9, 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, finger, and HTTP. Chapter 10, Sockets for Servers,

shows you how to use the

ServerSocket

class to write servers for these and other pro-

tocols in Java. Chapter 11, Secure Sockets, shows you how to protect your client

server communications using the Secure Sockets Layer (SSL) and the Java Secure

Sockets Extension (JSSE).

Chapter 12, Non-Blocking I/O, covers the new I/O APIs introduced in Java 1.4.

These APIs were specifically designed for network servers. They 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 simulta-

neously, 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 con-

nections, but they provide huge 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.

Chapter 13, UDP Datagrams and Sockets, introduces the User Datagram Protocol

(UDP) and the associated

DatagramPacket

and

DatagramSocket

classes that provide fast,

unreliable communication. Finally, Chapter 14, Multicast Sockets, shows you how to

use UDP to communicate with multiple hosts at the same time. All the other classes

that access the network from Java rely on the classes described in these five chapters.

Chapters 15 through 17 look more deeply at the infrastructure supporting the

URL

class. These chapters introduce protocol and content handlers, concepts unique to

Java that make it possible to write dynamically extensible software that automati-

cally understands new protocols and media types. Chapter 15, URLConnections,

describes the class that serves as the engine for the

URL

class of Chapter 7. It shows

you how to take advantage of this class through its public API. Chapter 16, Protocol

Handlers, also focuses on the

URLConnection

class but from a different direction; it

shows you how to subclass this class to create handlers for new protocols and URLs.

Finally, Chapter 17, Content Handlers, explores Java’s somewhat moribund mecha-

nism for supporting new media types.

Chapters 18 and 19 introduce two unique higher-level APIs for network programs,

Remote Method Invocation (RMI) and the JavaMail API. Chapter 18, Remote

Method Invocation, introduces this powerful mechanism for writing distributed Java

applications that run across multiple heterogeneous systems at the same time while

communicating with straightforward method calls just like a nondistributed pro-

gram. Chapter 19, The JavaMail API, acquaints you with this standard extension to

Java, which offers an alternative to low-level sockets for talking to SMTP, POP,

This is the Title of the Book, eMatter Edition

xvi

Preface

IMAP, and other email servers. Both of these APIs provide distributed applications

with less cumbersome alternatives to lower-level protocols.

Who You Are

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

environment, 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 and applets. You

should also be comfortable with basic AWT and Swing programming. When you

encounter a topic that requires a deeper understanding for network programming

than is customary—for instance, threads and streams—I’ll cover that topic as well,

at least briefly.

You should also be an accomplished user of the Internet. I will assume you know how

to FTP files and visit web sites. You should know what a URL is and how you locate

one. You should know how to write simple HTML and be able to publish a home page

that includes Java applets, although you do not need to be a super web designer.

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

programming. You should find it a complete introduction to networking concepts

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

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

what you need to know about these here. It’s certainly possible that you could use

this book as a general introduction to network programming with a socket-like inter-

face, and then go on to learn WSA (the Windows Socket Architecture) and figure out

how to write network applications in C++. But it’s not clear why you would want to:

as I said earlier, Java lets you write very sophisticated applications with ease.

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 many make heavy use of GUIs. This book is written with

the assumption that you and your customers are using at least Java 1.1. In general, I

use Java 1.1 features like readers and writers and the new event model freely without

further explanation.

Java 2 is a bit more of a stretch. Although I wrote almost this entire book using Java 2,

and although Java 2 has been available for most platforms for several years, no Java 2

runtime or development environment is yet available for MacOS 9. It is virtually cer-

tain that neither Apple nor Sun will ever port any version of Java 2 to MacOS 9.x or

earlier, thus effectively locking out 60% of the current Mac-installed base from future

This is the Title of the Book, eMatter Edition

Preface

xvii

developments. This is not a good thing for a language that claims to be “write once,

run anywhere.” Furthermore, Microsoft’s Java virtual machine supports Java 1.1

only and does not seem likely to improve in this respect for the foreseeable future.

Thus, while I have not shied away from using Java 2–specific features where they

seemed useful or convenient—for instance, the ASCII encoding for the

InputStreamReader

and the keytool program—I have been careful to point out my use

of such features. Where 1.1 safe alternatives exist, they are noted. When a particular

method or class is new in Java 1.2 or later, it is noted by a comment following its

declaration like this:

public void setTimeToLive(int ttl) throws IOException // Java 1.2

To further muddy the waters, there are multiple versions of Java 2. At the time this

book was completed, the current release was the “Java™ 2 SDK, Standard Edition,

v 1.4.2_05”. At least that’s what it was called then. Sun seems to change names at

the drop of a marketing consultant. In previous incarnations, this is what was sim-

ply known as the JDK. Sun also makes available the “Java™ 2 Platform, Enterprise

Edition (J2EE™)” and “Java™ 2 Platform, Micro Edition (J2ME™)”. The Enter-

prise Edition is a superset of the standard edition that adds features like the Java

Naming and Directory Interface and the JavaMail API that provide high-level APIs

for distributed applications. Most of these additional APIs are also available as

extensions to the standard edition, and will be so treated here. The Micro Edition is

a subset of the standard edition targeted at cell phones, set-top boxes, and other

memory, CPU, and display-challenged devices. It removes a lot of the GUI APIs

programmers have learned to associate with Java, although surprisingly it retains

many of the basic networking and I/O classes discussed in this book. Finally, when

this book was about half complete, Sun released a beta of the “Java™ 2 SDK, Stan-

dard Edition, v1.5”. This added a few pieces to the networking API, but left most of

the existing API untouched. Over the next few months Sun released several more

betas of JDK 1.5. The finishing touches were placed on this book and all the code

tested with JDK 1.5 beta 2. You shouldn’t have any trouble using this book after 1.5

is released. With any luck at all, discrepancies between the final specification and

what I discuss here will be quite minor.

To be honest, the most annoying problem with all these different versions and edi-

tions was not the rewriting they necessitated. It was figuring out how to identify

them in the text. I simply refuse to write Java™ 2 SDK, Standard Edition, v1.3 or

even Java 2 1.3 every time I want to point out a new feature in the latest release of

Java. I normally simply refer to Java 1.1, Java 1.2, Java 1.3, Java 1.4, and Java 1.5.

Overall, though, the networking API seems fairly stable. Java 1.1 through Java 1.3

are very similar, and there are a few only major additions in Java 1.4 and 1.5. Very

little of the post-1.0 networking API has been deprecated.

This is the Title of the Book, eMatter Edition

xviii

Preface

About the Examples

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

complete 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 pro-

gram, 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 excessively 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 are guar-

anteed to 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 occu-

pies in Java. The apparent 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 avail-

able online, often with corrections and additions. You can download the source code

from http://www.cafeaulait.org/books/jnp3/.

This book assumes you are using Sun’s Java Development Kit. I have tested all the

examples on Linux and many on Windows and MacOS X. Almost all the examples

given here should work on other platforms and with other compilers and virtual

machines that support Java 1.2 (and most on Java 1.1, as well). The occasional

examples that require Java 1.3, 1.4, or 1.5 are clearly noted.

Conventions Used in This Book

Body text is Times Roman, normal, like you’re reading now.

monospaced typewriter font

is used for:

• Code examples and fragments

• Anything that might appear in a Java program, including keywords, operators,

data types, method names, variable names, class names, and interface names

• Program output

• Tags that might appear in an HTML document

剩余761页未读，继续阅读

小月施主

粉丝: 187
资源: 660

Java网络编程基础：第3版精华解读

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

[Java网络编程(第3版,2004)].(Java.Network.Prog.epub

Java.Network.Programming(4th,2013.10)].Elliotte.Rusty.Harold.文字版.epub

java network programming by Elliotte Rusty Harold

Java Network Programming 3rd Edition By Elliotte Rusty Harold 2004

Java网络编程（第三版）中文版.part12.rar

Java网络编程（第三版）中文版.part03.rar

Java网络编程（第三版）中文版.part10.rar

Java网络编程（第三版）中文版.part13.rar

Java网络编程（第三版）中文版.part08.rar

最新资源