深入学习Java网络编程第三版

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

"Java Network Programming, 3rd Edition 是一本关于Java网络编程的书籍，主要探讨如何在Java平台上进行网络通信和应用开发。书中可能涵盖了套接字编程、多线程、网络协议、数据传输、网络安全等多个方面的内容。此书是O'Reilly出版社出版的，该出版社还提供了其他与Java相关的资源，如Enterprise JavaBeans、Java and XML、Java Cookbook等。此外，O'Reilly的在线平台Safari Bookshelf提供了丰富的在线参考图书馆，供程序员和IT专业人士进行搜索和学习。" 在Java网络编程中，开发者需要掌握以下几个关键知识点： 1. **Java网络API**：包括Socket和ServerSocket类，用于实现客户端-服务器通信。这些类位于`java.net`包中，是进行低级网络编程的基础。 2. **多线程**：由于网络通信通常涉及并发处理多个连接，因此理解和使用Java的线程模型至关重要。Thread类和Runnable接口是实现并发的基本工具，而ExecutorService和Future接口则提供了更高级的线程管理和任务调度功能。 3. **URL和URLConnection**：Java通过URL类和URLConnection类提供了对网络资源的访问。可以用来下载文件、发送HTTP请求等。 4. **网络协议**：理解TCP/IP协议栈，包括TCP、UDP等传输层协议，以及HTTP、FTP、SMTP等应用层协议，是编写网络应用程序的关键。 5. **输入/输出流**：Java的I/O框架对于在网络中读写数据至关重要。BufferedReader、BufferedWriter、DataInputStream、DataOutputStream等类用于处理字符和字节流。 6. **网络安全**：涉及到SSL/TLS加密、数字证书、网络安全策略等，确保数据在传输过程中的安全。 7. **NIO（非阻塞I/O）**：Java的非阻塞I/O API（New I/O，`java.nio`包）允许程序处理更多的连接，特别适合高并发的服务器端编程。 8. **Java EE相关技术**：如Servlet、JSP、EJB等，它们提供了更高级别的Web服务和企业级应用开发框架。 9. **远程方法调用（RMI）**：Java的RMI允许在不同的Java虚拟机之间透明地调用方法，是分布式计算的基础。 10. **网络调试和性能优化**：学会使用网络工具如Wireshark进行网络包捕获分析，以及如何优化网络应用的性能和响应速度。通过阅读《Java Network Programming, 3rd Edition》这样的书籍，读者可以系统地学习和实践上述知识，提升Java网络编程技能，为构建高效、可靠的网络应用打下坚实基础。同时，O'Reilly出版社提供的相关资源和在线平台Safari Bookshelf，为学习者提供了丰富的补充材料和实时更新的信息，进一步促进专业技能的提升。

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.

A 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

www.allitebooks.com

剩余761页未读，继续阅读

kernelkoder

粉丝: 57
资源: 317

深入学习Java网络编程第三版

Java Network Programming 3rd Edition By Elliotte Rusty Harold 2004

java网络编程 Java.Network.Programming.3rd.Edition.Oct.2004

Foundations of Python Network Programming, 3rd Edition.zip

Unix Network Programming Volume 1 3rd edition

Foundations of Python Network Programming, 3rd Edition.pdf 英文原版. Python网络编程基础

Java_Network_Programming_3rd_Edition_2004.rar_java programming

Core Python Applications Programming (3rd Edition)

数据库基础测验20241113.doc

微信小程序下拉选择组件

DICOM文件+DX放射平片-数字X射线图像DICOM测试文件

最新资源