没有合适的资源?快使用搜索试试~ 我知道了~
首页Java网络编程实战:第4版全面覆盖JDK 1.5更新
"Java Network Programming" 是一本备受推崇的入门书籍,专门针对Java网络编程进行了详尽的讲解。第三版更新至Java Developers Kit (JDK) 1.5之后,它全面涵盖了超过100多项关键更新,使读者能够掌握开发网络应用(包括Applets和应用程序)所需的所有基础知识,直至高级技术如远程方法调用(RMI)。 该书内容涵盖了广泛的网络编程领域,包括TCP和UDP套接字,多播协议与内容处理,Servlets(服务器端程序组件),多线程网络编程,I/O操作,HTML解析与显示,Java邮件API以及Java安全套接字扩展(Secure Sockets Extension)。特别值得一提的是,书中对新I/O API进行了深入剖析,这个API正是针对网络程序员的需求而设计的,对于编写复杂网络应用至关重要。 作者Elliotte Rusty Harold以其丰富的经验和深入浅出的讲解,确保读者能够通过大量的实用例子迅速上手。无论你是初学者还是经验丰富的Java开发者,这本书都是构建高质量网络应用的不可或缺的参考资源。本书不仅适用于教育、商业或销售推广用途,还提供在线版本供用户访问。 第四版的发布在2013年9月23日,书中提供了详细的修订历史,确保了内容的最新性和准确性。此外,封面设计、内部设计以及插图由知名设计师团队完成,为读者提供了良好的阅读体验。总体来说,"Java Network Programming, Fourth Edition" 是所有Java开发者在进行网络编程时的理想指南,无论是为了学习新技能还是提升现有知识,都是一份宝贵的财富。
资源详情
资源推荐
you to start using Java as a platform for serious network programming. To do so, this
book provides a general background in network fundamen
tals, 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
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. Cha
pter 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
Chapter 12, UDP, in
troduces 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
relatively minor. You shouldn’t have any trouble using this book after Java 8 is released.
N
ew 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
Conventions Used in This Book
B
ody text is Minion Pro, 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 in
terface names
• Program output
• Tags that might appear in an HTML document
A bold monospaced font is used for:
• Command lines and options that should be typed verbatim on the screen
An italicized fon
t is used for:
• New terms where they are defined
• Pathnames, filenames, and program names (however, if the program name is also
the name of a Java class, it is given in a monospaced font, like other class names)
• Host and domain names (www.hpmor.com)
• URLs (http://www.cafeaulait.org/slides/)
• Titles of other books (Java I/O)
Indicates a tip, suggestion, or general note.
Indicates a warning or caution.
Significant code fragments and complete programs are generally placed into a separate
paragra
ph, like this:
Socket s = new Socket("java.oreilly.com", 80);
if (!s.getTcpNoDelay()) s.setTcpNoDelay(true);
xviii | Preface
剩余501页未读,继续阅读
FireFoxAhri
- 粉丝: 4
- 资源: 7
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- zlib-1.2.12压缩包解析与技术要点
- 微信小程序滑动选项卡源码模版发布
- Unity虚拟人物唇同步插件Oculus Lipsync介绍
- Nginx 1.18.0版本WinSW自动安装与管理指南
- Java Swing和JDBC实现的ATM系统源码解析
- 掌握Spark Streaming与Maven集成的分布式大数据处理
- 深入学习推荐系统:教程、案例与项目实践
- Web开发者必备的取色工具软件介绍
- C语言实现李春葆数据结构实验程序
- 超市管理系统开发:asp+SQL Server 2005实战
- Redis伪集群搭建教程与实践
- 掌握网络活动细节:Wireshark v3.6.3网络嗅探工具详解
- 全面掌握美赛:建模、分析与编程实现教程
- Java图书馆系统完整项目源码及SQL文件解析
- PCtoLCD2002软件:高效图片和字符取模转换
- Java开发的体育赛事在线购票系统源码分析
资源上传下载、课程学习等过程中有任何疑问或建议,欢迎提出宝贵意见哦~我们会及时处理!
点击此处反馈
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功