Customer Reviews

Java Network Programming (Java (O'Reilly))

5 star:		(18)
4 star:		(8)
3 star:		(3)
2 star:		(3)
1 star:		(5)

 

 

Avoid. This book appears to have quite a reputation, but despite being in its 2nd edition, it is riddled with errors. The book exhibits some fundamental misapprehensions about TCP/IP; as a result it perpetrates some astonishing misinformation, much of it quite basic. Partial list: the nature of a socket close operation; what IOException when closing a socket means; what happens when the listen backlog is exceeded; specification of the ServerSocket constructors; Nagle's algorithm (Socket.setTcpNoDelay); linger; keepalive; etc etc.

Of the examples which do work, the PortScanner and LocalPortScanner are provided in versions which perpetrate atrocities on the local machine and network by not closing sockets. Multi-homing very cursorily treated, not even indexed. Firewalls apparently treated in one page. Role of TTL in multicast apparently ignored.

The text is verbose and repetitive, and a number of the examples are irrelevant. Fully 50% of the Sockets for Servers chapter consists of a rather irrelevant excursion into HTTP and HTML; the examples have bugs, not that they have much point. Also, what pray have HTML rendering and parsing in Swing got to do with networking? 30 irrelevant pages on this; nice to have, but why here?

Author seems to think HotSpot is a JIT. Typos in the index, not encouraging. Many impending JDK 1.4 enhancements will shortly obsolete this book. Avoid it. For TCP/IP and UDP fundamentals, buy W.R. Stevens Unix Network Programming. -

I love this book. Absolutely love it. One of the great things here is the tie in of network programming with java's IO classes. Networking in Java is IO, and this book explains it upfront.

The overviews of IO and Threading in the first couple of chapters can really solidify these topics if you are sketchy on them. The rest of the book is dedicated to going over the .net classes & explaining each one, providing in depth/useful examples for each.

The appendix of the book give a good enough overview of RMI & JavaMail, more than enough to get you going using either package.

While this is not a book for total beginners, if you need to learn the .net package, or want to take your Java skills to the network, buy this book!

If you're doing anything with Java and Network I/O programming, the topic will most likely be covered in this book. The author does a great job describing not only how Java handles network programming, but the concepts and details of network programming in general. The book takes the core java.net classes and describes each method, what it does, how to use it, what to watch for, code examples, etc - it takes the API Javadoc and expands upon it.

It's a great Java Network API reference book.

This book is pretty complete as far as covering the fundamentals of java network programming is concerned.However, it provides not much more information than what the first edition covered.Most of the chapters seem the same, and some have been re arranged.Manning's book covers more topics,but this book gives better explanation of the concepts like RMI etc.Overall, a good addition to the shelf,but if you already have the first edition of this book, might want to consider Manning's book instead.

The value of this book is in the depth of the coverage it gives to every topic. As opposed to the usual code fragments glued together with the necessary minimum of expository text, this book takes it's time to explain topics in detail. It's clear that in it's third revision the author has learned how to teach the Java network APIs.

Topics covered include both client and server code with sockets and UDP, non-blocking I/O, and protocol and content handlers, as well as many others. This is very in-depth, very well written with effective use of graphics. And better yet you will learn about the protocols themselves as well as the APIs.

This is an outstanding book, easily the best book, on the Java network APIs.

This book covers all the important things to know about network programming in JDK1.3 and Java2. The content and quality is how you expect it from O'Reilly books: thorough, complete, practical with clear examples, and with a good theoretic foundation.

The first three chapters provide theory about basic network and web concept and explains what you can do with Java networking. A lo of very interesting things, and that motivated me to read further. Chapter 4 and 5 are about Java I/O and threads and might be redundant for Java programmers, who already know basic Java stuff. But those chapters are necessary to understand the examples in all the following chapters. Chapter 6-19 deal with all the various networking topics and Java classes that deal with URL's, Internet addresses, sockets and datagrams, protocol and content handlers, RMI and JavaMail. The organization of these last chapters is topical; in most of the times you can understand a chapter without reading the previous ones, just pick out the one that you are interested in. (Interesting chapter about parsing HTML with JEditorPane, Swing has some unexpected applications!)

I think the author gave a complete and thorough coverage of all the necessary topics. The author does not stray from its topics, is sometimes a bit dry in his explanations, and gives some important side information, e.g. about security aspects of the different Java versions in regards to RMI.

Take in mind that this is the second edition from August 2000, updated to Java2, with some 200 or more extra pages, and we can use this book for the next couple of years.

I had a couple years experience with Java, but knew nothing about network programming. I bought this book, and started writing fairly sophisticated network code (chat rooms, online games, web browsing software, etc.) by the time I was halfway through. I wouldn't recommend this book to Java beginners, but I would definitely recommend it to more experienced Java coders who are new to network programming. Since some readers have complained that this book is out of date, I would remind everyone that a new edition is due out in August of 2000. Don't be swayed by anyone who rates this book solely on the basis that it is outdated; just hold out for the second edition.

If you carefully go thru all the reviews , you can make out that the reviews in 1997 give a very positive feedback about the book. But at this point of time this book definetely needs a revision.

If you really want to understand how networking works in Java, buy this book and read it. You will not be disappointed.

The book does an excellent job of documenting how the java.net package works and an even better job of displaying useful examples. Very rarely do I find my self compiling and running code examples given in books. However, with this book I did it routinely because they were just to tempting not to run!

I found the chapters on HTML parsing, Threads, Sockets, JavaMail and RMI to be the most useful.

This book begins with three chapters that outline how networks and network programs work. Chapter 1 is a gentle introduction to network programming in Java and explores some of the unique programs that become feasible when networking is combined with Java. Chapters 2 and 3 explain in detail what a programmer needs to know about how the Internet and the Web work. Chapter 2 describes the protocols that underlie the Internet, such as TCP/IP and UDP/IP. Chapter 3 describes the standards that underlie the Web, such as HTTP, HTML, and REST.

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.