Server-Based Java Programming

I'll be honest, I'm an O'Reilly fan. If there's a book on a subject with a furry little animal on the front, then that's the one for me. So I was a little leary when a friend of mine passed this book along to me. Well let me tell you, this book is fantastic.This is the first book I've found with such a thorough coverage of java server programming. Be forewarned, when they talk about Server-Based Java programming, they aren't talking about servlets and JSP for web projects. If you're looking for such a book, you're better off looking elsewhere. This book has excellent coverage of issues involved in programming middle-tier and backend server java for use in enterprise level systems. The sections on server threading issues and code deployment are worth the cost of the book alone. But then they throw in RMI, Corba, and JNI for helping you integrate your components with other applications.The book is noticeably light on EJB's, but this is by design. So you may wish to pick up a companion book if that's your aim. However, even if your focusing on EJB's, this is a highly useful book for the underlying server architecture that the EJB's will reside on.

Whether you're building your own Java application server, or evaluating your options when it comes to building an enterprise class application, there's an awful lot to consider. Everyone likes to throw around the adjective 'enterprise'; 'enterprise class,' 'enterprise information system,' 'enterprise solution' but what does this mean? What is an enterprise solution? And more importantly how do you build one? This book cuts through the J2EE hype and gives you the straight dope on desiging/implementing realistic java based distributed systems.As a Sun Certified Java 2 Developer, I've read more than my fare share of bad java books. The good thing is that they are very easy to spot: they are typically extremely thick books with trivial examples and a huge API reference (that you can download from Sun's website) for filler. This book is a voice of reason in Sun's flood of J2EE (especially EJB) hype. It's a wholly remarkable Java book. Ted Neward should be rewarded and congratualted for this book, it sets a new standard in content quality for Java books.

I was going to write a review on this book, because I found it very useful... but then after reading all the other reviews, I have not much to write! I agree with most!It is very common these days just to modify product manuals, or specs and call it a book. This book shines with its original approach, in-depth information and practical examples; you will learn both basics and behind the sceene server side Java: a six stars book!

Now this was a refreshing book!When I first glanced through the contents of "Server-Based Java Programming" at the bookstore, I almost immediately put it back on the shelf. After all, it barely even mentioned J2EE. Who on earth writes a book about using Java on the server without covering J2EE? That's the hot technology and everyone is focusing on and certainly the basis for Java development on the server. Using an application framework provided by J2EE provides too much to ignore - why would you write anything else?Well, I was wrong. Long story short - I ended up with a copy at my desk. Finally I picked it up and started reading.Hours later and I still couldn't put it down.Ted Neward's book Java-Based Server Programming, published by Manning Publications covers much more than simple J2EE development. It gives you the tools you need in order to understand and develop your own servers, application or otherwise. While this may not seem important at the surface (see my own remarks earlier), it becomes readily apparent only a few pages in just how valuable these skills are. Having the depth of understanding that's presented in this book gives you the ability to write code of greater robustness than otherwise, whether you're writing J2EE apps or not.The first thing that struck my fancy was the discussion about the 3 zeroes - zero development, zero deployment, and zero administration. I've long been an advocate of building "lights out" systems - put it on the servers, shut off the lights and go home and wait for the checks. But Ted takes it beyond what I had considered. Lofty goals, no doubt, zero development, deployment & administration is exactly what we should be shooting for. As the saying goes, "Shoot for the stars and hit the sky, shoot for the sky and hit the mud."If that was all he had to say it would have been a good purchase, but Ted then goes on to describe and produce code that actually moves us toward these goals.I appreciated the frequent references to design patterns. In many circles patterns are new concepts that people are just starting to experiment with. It is refreshing to see a book where the audience is expected to understand them. UML is used where appropriate, adding yet more evidence that this is written by an architect and software engineer - not just someone throwing code together quick and dirty.It's not as though all the material in the book is new and doesn't exist elsewhere. There are many texts that cover threads and their proper use. Texts about n-tier architectures abound. Application frameworks are not new concepts; sockets, persistence, servlets, middleware and JNI have been around and are well-understood. The power comes through the stated objectives and the practical application of these different technologies in a holistic manner toward them that produces a very worthy text.Real-world, architecture-centric, holistic, practical, proven. All appropriate words to describe this book. Don't bel

As a systems architect I found this book extremely useful. It is an excellent book for those involved in serious server-side architecture, design and development. The book is organized into seventeen sections covering Enterprise Java, threads, control, configuration, Sockets, Servlets, persistence, middleware, JNI, monitoring, and two sections devoted to an excellent discussion of business objects and business object models. As an example of the level of this book, the beginning of the Servlet section states that the author is not going to go over Servlet basics in this chapter - rather he immediately dives into the various uses of Servlets within an Enterprise architecture (a refreshing change!).Throughout the book the author identifies real-world problems and issues facing server-side design, and presents several solutions to these problems. Both the Servlet and Business Object Model sections have excellent discussions about n-tier application issues pertaining to the separation between logic, content, and presentation. These sections make excellent reading. Rather than being theoretical about the issues the author describes real-world situations and ways to work around them. A few examples of the issues the author describes in these sections are team development of common modules, n-tier client-side validation, and scalability and performance.Having read this book cover-to-cover (something I rarely do with technical books), there were a few sections that I did not find useful. These sections were the ones on ClassLoaders, Custom ClassLoaders, and Java Native Interface. Also, I felt the section on Configuration was a bit weak, and did not address many of the issues I have faced with configuration issues involving distributed systems. Overall, this is an excellent book, one that is now included in my "Top 5" list of technical books.