Java网络编程入门：Elliotte Rusty Harold指南

java

需积分: 0 182 浏览量更新于2024-07-27 收藏 10.16MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"Java网络编程 (Elliotte Rusty Harold)" 在过去的十年间，Java的发展势头堪称惊人。随着Java的迅速崛起以及互联网的爆炸性增长，对于很多人来说，Java的网络编程仍然充满神秘。但实际上，正如这本书所展示的，用Java编写网络程序相当简单。对于那些有Unix、Windows或Macintosh环境下网络编程经验的读者来说，他们可能会惊喜地发现，使用Java编写类似的程序比C或C++更容易。Java的核心API提供了设计精良的接口，几乎涵盖了所有网络特性。这使得你在Java中可以编写大多数应用层网络软件，甚至比在C或C++中更便捷。《Java网络编程》第三版旨在向读者展示如何利用Java的网络类库，快速轻松地编写完成各种常见网络任务的程序。这些任务包括但不限于： 1. 建立TCP和UDP连接：Java提供了Socket和DatagramSocket类来处理面向连接和无连接的通信，它们是进行网络数据传输的基础。 2. HTTP客户端和服务器：通过HttpURLConnection和ServerSocket，你可以创建能够处理HTTP请求和响应的应用，这对于Web服务的开发至关重要。 3. 多线程和并发：Java的Thread类和ExecutorService接口允许开发者有效地管理多个并发网络任务，确保高效的数据交换。 4. URL和URI操作：Java.net包中的URL和URI类提供了对统一资源定位符和统一资源标识符的操作，方便访问网络资源。 5. 输入输出流：InputStream和OutputStream类族为网络数据传输提供了基础的读写功能，而BufferedReader和BufferedWriter则提供了缓冲能力，提高了效率。 6. 序列化和对象流：通过Serializable接口和ObjectInputStream/ObjectOutputStream，Java支持在网络间传输对象，实现分布式系统的组件通信。 7. DNS解析：InetAddress类提供了域名到IP地址的转换，这对于网络通信的初始化是必要的。 8. 安全性：Java提供SSL/TLS支持，通过SSLSocket和SSLServerSocket实现安全的网络通信，防止数据被窃取或篡改。 9. NIO（非阻塞I/O）：Java NIO库（java.nio包）引入了通道和选择器，使程序能同时处理多个连接，适合高性能服务器端编程。此外，O'Reilly出版社还提供了众多与Java相关的资源，如书籍、样本章节、代码示例、在线参考图书馆Safari Bookshelf，以及OnJava.com网站上的新闻、代码食谱、访谈和博客等，为Java开发者提供了全面的学习和交流平台。参加O'Reilly组织的会议也是获取最新工具和系统知识、提升技能的好途径。无论你是初学者还是资深开发者，都能在这个丰富的资源库中找到所需的信息和支持。

资源详情

资源推荐

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

gotonewpoint

粉丝: 0
资源: 6

Java网络编程入门：Elliotte Rusty Harold指南

javaworkweb

javaWork.rar

svn: Working copy 'I:\jdk1.6.0_45\JavaWork\DFEP\src\com\ep\crm\mwms005' locked

UnsatisfiedLinkError: D:\JavaWork\map\bin\XZFXLib.dll: Can't find dependent libraries

Windows Defender 可能会影响您的构建性能。IntelliJ IDEA 检查了以下目录： D:\javawork1 C:\Users\zhm\AppData\Local\JetBrains\IntelliJIdea2020.1

D:\javaWork\WorkTX\daoyuan\trunk\src\com\landray\kmss\kms\iso\cs\wordimg\work.java:34:13 java: 找不到符号 符号: 方法 setRotate(int) 位置: 类型为org.apache.poi.xwpf.usermodel.XWPFRun的变量 run

知乎竞赛.zip

国防知识竞赛.zip

天池大数据竞赛项目--电力预测.zip

美国数学建模竞赛C题代码-Amazon Rating Prediction.zip

技术资料MR-E伺服重要开发资料.zip

【SCI2区】基于VMD-遗传算法GA-LSTM光伏预测Matlab实现.rar

AzureK-2.5.2-py3-none-any.whl.zip

基于ssm的热带水果商城设计与实现.docx

竞赛.zip

基于ssm的网上订餐系统设计与实现.docx

基于ssm的摄影约拍系统设计与实现的设计.docx

032531-铁磁学（下册）.pdf

BAAlgorithmUtils-1.1.3-py3-none-any.whl

最新资源

D:\javaWork\WorkTX\daoyuan\trunk\src\com\landray\kmss\kms\iso\cs\wordimg\work.java:34:13 java: 找不到符号符号: 方法 setRotate(int) 位置: 类型为org.apache.poi.xwpf.usermodel.XWPFRun的变量 run