- Paperback: 504 pages
- Publisher: O'Reilly Media; Third edition (October 2004)
- Language: English
- ISBN-10: 0596007213
- ISBN-13: 978-0596007218
- Product Dimensions: 7 x 1.7 x 9.2 inches
- Shipping Weight: 3.1 pounds (View shipping rates and policies)
- Average Customer Review: 28 customer reviews
- Amazon Best Sellers Rank: #1,177,702 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Java Network Programming, Third Edition Third Edition
Use the Amazon App to scan ISBNs and compare prices.
Customers who viewed this item also viewed
Customers who bought this item also bought
About the Author
Elliotte Rusty Harold is originally from New Orleans to which he returns periodically in search of a decent bowl of gumbo. However, he currently resides in the University Town Center neighborhood of Irvine with his wife Beth, dog Shayna, and cats Charm (named after the quark) and Marjorie (named after his mother-in-law). He's an adjunct professor of computer science at Polytechnic University where he teaches Java, XML, and object oriented programming. He's a frequent speaker at industry conferences including Software Development, Dr. Dobb's Architecure & Design World, SD Best Practices, Extreme Markup Languages, and too many user groups to count. His open source projects include the XOM Library for processing XML with Java and the Amateur media player.
Showing 1-6 of 28 reviews
There was a problem filtering reviews right now. Please try again later.
My biggest complaint is that the book is basically a glorified API with some very boring examples. Each chapter explains the methods and constructors of a certain class then throws them together in a sample program.
In my opinion, the book should have included more ideas and concepts and logic used in networking. It doesn't really discuss how networking relates to most of the things any given programmer would like to do. The book's cover and description leads you to believe otherwise, to believe it's more than a strict reference. Unfortunately, it isn't.
Another complaint is that the book is a terribly dry read and almost completely devoid of illustrations. This makes things terribly confusing when discussing things that might be new to you such as sockets.
It's not a bad book overall, it's just bad at some things. Admittedly, a great desk reference, and no one can deny that the API docs can be cryptic at times.
Good reference, mediocre instruction. Nice to have but might not be enough.
The coding examples are all well explained and are always complete - something I totally appreciate. However, some of the coding techniques could be rather simplified and I feel the book doesn't provide enough bibliography to help you expand more.
This is a great book to introduce you into the world of java networking, but if you want to get to the top, you'll eventually need more. It's, IMO, a good book for starters that I recommend to everyone.
The next two chapters discuss two parts of Java programming that are critical to almost all network programs but are often misunderstood and misused - I/O and threading. Chapter 4 explores Java's classic I/O models which, despite the new I/O APIs, are still the preferred means of handling I/O 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 5, explores multithreading and synchronization, with a special emphasis on how they can be used for asynchronous I/O and network servers. Chapter 6 shows how Java programs interact with the domain name system through the InetAddress class, the one class that's needed by essentially all network programs.
Chapter 7 explores Java's URL class, which enables you to connect to and download files and documents from a network server without concerning yourself with the details of the server's protocol. 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. Chapter 8 introduces some little known classes for parsing and rendering HTML documents that make this task easy.
Chapters 9 through 11 discuss Java's low-level socket classes for network access. Chapter 9 introduces the Java sockets API and the Socket class in particular. It shows how to write network clients that interact with TCP servers of all kinds including whois and HTTP. Chapter 10 shows how to use the ServerSocket class to write servers for these and other protocols in Java. Chapter 11 shows how to protect your client server communications using the Secure Sockets Layer (SSL) and the Java Secure Sockets Extension (JSSE).
Chapter 12 covers the I/O APIs that were 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 simultaneously, thereby placing much less load on the virtual machine. These APIs primarily provide huge performance boosts for high volume servers. Chapter 13 introduces the User Datagram Protocol (UDP) and the associated DatagramPacket and DatagramSocket classes, and Chapter 14 shows how to use UDP to communicate with multiple hosts simultaneously.
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 automatically understands new protocols and media types. Chapter 15 describes the class that serves as the engine for the URL class of Chapter 7. It shows how to take advantage of this class through its public API. Chapter 16 also focuses on the URLConnection class, but from a different direction; it shows how to subclass this class to create handlers for new protocols and URLs. Finally, Chapter 17 explores Java's mechanism for supporting new media types.
Chapter 18 introduces RMI, which enables distributed Java applications to run across multiple heterogeneous systems simultaneously, while communicating with straightforward method calls just like a nondistributed program. Chapter 19 discusses JavaMail, which is an alternative to low-level sockets for talking to SMTP, POP, IMAP, and other email servers.
This book assumes you are an experienced Java programmer. Thus, you should be comfortable with basic AWT and Swing programming, since some of the code examples use these APIs. It is assumed that you know the basics of computer networking - how to use the Internet, what a URL is, how to FTP files, and write simple HTML. However, it assumes no prior experience with network programming. I found the book to be complete and in-depth. The code examples are plentiful, non-trivial, and well commented. I would recommend it not only as a tutorial in Java network programming but as a reference for someone who already knows the subject.
The examples do not compile ( currently code examples on O'Reilly site are unreachable ), so they are useless as quick and dirty sample pieces of code, that can be built upon.
My major problem was that I could never understand what he was actually trying to do, so it was very hard to fix the examples. For example, an example gets the IP address for a www site. It also works for an IP on the local net. But this is not mentioned, and I would love to know why it works.
Also since we are comparing host names, it would be nice to know how to determine if a host name is your localhost. This is never shown. The basic problem is that it is a Java 1.0 book that was never really updated to 1.1. This is obvious because of the amount spent discussing V1.0 issues that don't apply to V1.1.
I will probably struggle with it for a bit more, and then move to something else.
I feel that I could have learnt as much just by reading the class definitions.