Customer Reviews

How Tomcat Works

5 star:		(9)
4 star:		(5)
3 star:		(1)
2 star:		(2)
1 star:		(0)

 

 

I became interested after reading Richard Monson-Haefel's praising this book in his blog (http://weblogs.java.net/pub/wlg/1372). After reading the
six free chapters from the publisher's site (www.brainysoftware.com), I decided to buy. This is a truly amazing book that covers such an advanced topic in such a simple language. I feel I do understand the internals of Tomcat now. The first Tomcat component you can build after reading this book is as simple as 20 lines or so, as demonstrated in the publisher's site. Supporting technologies, such as shutdown hook, Digester, JMX, are also well explained so that you will be really prepared to wade through complex code.

I bought Budi's newest book because I liked the style of his earlier book on JavaServer Faces. He has an ability that is rare for most technical authors...He can make a very complex topic understandable.

Although Tomcat is pretty easy to set up and use as a developer, to really understand the internals of the server one must wade through thousands of lines of code and even then it can be a daunting task. Furthermore, understanding the "how" is only half the battle. To really gain an understanding of the server, one must understand "why" the Jakarta folks did things the way they did.

Budi (and Paul Deck) did a great job of not just giving a code review of the server, but also describing the reasons why the server is constructed the way it is.

Having written a few Tomcat Components the hard way - trial and error - I can say the insights given in this book have helped a great deal.

But, as I say in the title, this book is not for the squeemish. There is a sizable amount of fairly complex code. To really understand the point of the book, the reader must be VERY familiar with the Java language, Java Web Applications, TCP/IP, and be willing to ponder a code listing for a while to really understand it. In other words, this is not what I would call a "passive read".

If you have the basic understanding necessary, this book will shed a great deal of light on one of the darker corners of server-side Java development.

This is great read for anybody wanting to really understand the internals of Tomcat.

THis is a Tomcat book that lets you pick the brightest brains in the industry. This book shows how Tomcat developers designed and build Tomcat from scratch. Like me, I'm sure you'll learn a lot, much more than Tomcat configuration. For example, you'll learn how a Java HTTP server is written, how object pooling is implemented, how auto-reload works, ect. This is unlike other Tomcat books that are rehash of the free documentation at Tomcat's website.

Surprisingly, the language is simple. If you know a bit of Java, you can follow the chapters comfortably. It starts from a basic HTTP server and servlet container and works its way up to a full Tomcat. You'll enjoy it if you have interest in Java programming.

This is one of the best technical books I've ever read. This is so because the way the authors designed the book and written the 20 applications accompanying this book. I would say this is the only book that teaches its reader how to develop a major application such as Tomcat, literally line by line.

If you are a Java developer, this book teaches you how to design and write large-scale applications. If you are a Tomcat user, you'll learn much more from this book than from other books. If you want to take part in Tomcat development, this is the one you should grab to get you started. I highly recommend this to any Java architect and developer.

A good technical book is one that is easy to understand. And this book is clearly one of those. Tomcat is a very complex system, but in the authors' hands, it becomes easy to understand. The authors appeared to have put much effort in explaining many pieces of Tomcat very well. For example, Chapters 1 to 4 cover the connector. Most authors would have probably tried it in one chapter. Considering connectors are such a complex beast, four chapters rather than one do better. It showed how well designed this book was. It is also uncanny how the authors knew which to explain first and which topics should come later.

Another thing about this book is it is enjoyable, you want to start the next one as soon as you finish a chapter.
So, this is something you should read from page 1 to the last. The codes were based on TOmcat 4 and 5. They are very similar so the authors put notes explaining the differences between the two versions.

You'll learn a lot reading this book. The author started from a few lines of code in Chapter 1 (a Java web server) and built a simple servlet container (in CHapter 2) based on the code in chapter 1. It looks so simple and you don't realize that in the last chapter you get a full-blown Tomcat. On the way, you'll learn a lot of advanced Java topics too.

There are quite many spelling errors and I would really subtract half a star if I could. However, considering its merit I was happy to overlook it this time.

I was tempted to only give this book 3 stars, but it does in fact do what it claims to do - explain how tomcat works, literally line by line. Because it starts with the most basic example and then builds on each component one at a time, this is a book best read cover to cover. Many of the subsequent example applications assume knowledge explained in previous chapters, so I had trouble using it as the reference I had hoped for.

My biggest problem with this book is that is just stops short in so many places. In general the writing is very dry, even for a technical topic such as this. Additionally, the formatting of the book makes much of it hard to follow... the code seems to flow right into the text in parts. I believe this book was published independently, so I imagine there were budget constraints, but in this case I believe it sorely hurt the readability of the book. The authors' convention of class naming is also highly irregular and leads to much confusion in regards to which version of which class is being referenced. Finally, I was highly upset to see that the author doesn't touch on the inndards of Coyote (Tomcat5's new Connector) at all, even though it claims to "cover Tomcat 4 and 5". This is a highly significant package that is essential to understanding how connectors work in Tomcat5.

If you have the time and desire to learn Tomcat from the ground up, this should be fine. However, if you're looking for a reference for a specific part of Tomcat (such as the Connector, in my case), you might want to look further.

From what I've come to understand, this is a self-published title, and for that, I would say that they did quite a good job at it. If it were a book published by A&W or ORA I would have subtracted a star or two for bad editing, because it does have its fair share of typos and it could do with some proper editing.

So when I give this 4 stars it is solely based on the merits of the content.

I like the idea of the book. They use the internal APIs of Tomcat and then successively implement the various components. As the book progresses the components become more and more complete.

This is a good way of learning about a piece of software. I'd love more books to follow this format. If A&W or ORA were to offer these people a publishing deal, tighten up the writing and make some of the code more focused, I'd buy that book even though I own this one already.

This is best book to sit and read near by a fire but additionally you need a computer with you from time to time. I was very much pleased with the way author had described the interior design of Tomcat with reference to Catalina from a very simple component to the complex one. This book will sure help you to learn the big picture of Tomcat and its components and will also help you to run sample application servers.

It is highly recommended to download the code and use them as reference while reading and testing the chapters. This book covers both Tomcat 4 and 5 with a tiny note what has been changed from Tomcat 4 to 5.

I also liked the UML diagram and the collaboration diagram at the beginning of each/some chapters, this gives you the big picture of the package/class structure before you get into the very detail of every java class

After reading this book, if you happen to see some runtime errors from Tomcat, you will sure be able to say where and why it is happening

The book also act as a best documentation for entire Tomcat package, which you will not get even if you spend days on Tomcat website.

I would also recommend this book to any java programmer who want to see how a complex tool like Tomcat was build, which in-turn can help you to apply that knowledge while building your own in-house software.

Having recently finished TCP/IP illustrated, volume 2, which is a line-by-line treatment of the BSD networking code, I was hoping that "How Tomcat Works" would be as thoughtful and as comprehensive a treatment of Tomcat's code. It wasn't, and it fell far short of my expectations. For the most part, the value of the book comes from the author's organization of the source code - first look at the connectors, then look at containers, then look at wrappers, engines, hosts, etc. This organization is valuable if you're just sitting down to dissect the source, since it gives you a place to start. Otherwise, though, the book didn't provide much information that the source code itself (freely available) doesn't. The authors just present the source code and say, "there you go. That's it". They don't delve into the why or the how - they don't show how the sources tie together or discuss areas where Tomcat might be improved (or why it can't be improved in an otherwise obvious way). All in all, if you're the sort of person who'd be interested in reading this book, you probably already know everything it has to teach you.

A very useful and complete book for who want undestand tomcat machine, with very useful examples.