Customer Reviews

Java Message Service

5 star:		(12)
4 star:		(13)
3 star:		(4)
2 star:		(2)
1 star:		(4)

 

 

It's nice to have some material on JMS - it is very hot so plenty of employers are looking for those who know it. I especially like the way they have a chapter on the new message-driven beans in EJB 2.0. In general, this book is pretty complete covering both P2P and publish-subscribe. They give a decent amount of examples and cover the theory involved. JMS is not rocket science, it is pretty simple so if you've had alot of experience with messaging systems this may be repetitive for you. You could probably save money by checking out the JMS spec. However, if you're new to messaging systems, this will provide a nice, complete intro.

I found this book to be a very informative and accurate description of JMS. Having studied the JMS spec in great detail, I thought I knew everything there was to know about it. However, this book spells it out very clearly, puts it together in a way that is easily digestible. It explains the concepts clearly and continually builds on them with working examples as it goes. It provides information on subtleties like why and why not one would use the TopicRequestor object, and provides a very thorough discussion on guaranteed messaging, store-and-forward, and message acknowledgements.

It gives a good overview of the popular JMS vendors. In the preface it mentions that the technical reviewers for the book consisted in part of representatives from a number of JMS vendors. It is good to know that one of the co-authors of this book is from the SonicMQ team. Based on the level of detail described in the book, and the extensive list of names in the acknowledgements section, it is clear that David Chappell made good use of expert advice from the SonicMQ engineering team, and from the Sun team (Joe Fialli is the technical lead for Sun's JMS reference implementation). This book is not just a point of view from 2 guys who read a spec and regurgitated it. It is clear that it contains valuable and accurate information on a technology than from the engineers who built an implementation of it - from SonicMQ, Sun's JMS reference implementation, and other JMS vendors.

This book hits two flies in one smash: it gives a good background of messaging and JMS, and it is a good tutorial about the JMS API with lots of clear examples.

The first chapter gives a good and complete description of the messaging paradigm. Chapter 2-6 is the actual API tutorial. Chapter 2 gives you a simple and complete example of a chat application, chapter 3-6 explain all the aspects of the JMS API. The explanation is very clear and well structured with good feedback to previous explanations and messaging concepts, the reader never gets lost in the explanations and examples. And it is always clear for the reader why things have to be done a certain way.

Chapter 6 "Transacted Messages" also gives you a very short description of the JTA (supported by some JMS providers) API for two-phase commit transactions. Actually too short, I could not find a good tutorial in print elsewhere on this topic.

Chapter 7 "Deployment Considerations" is a very practical chapter for architects and deals with performance, scalability, reliabity, security, multicasting versus hub and spoke architecture.

Chapter 8 "J2EE, EJB, and JMS" describes the place of JMS in the J2EE platform and also describes new MessageDrivenBean type in the EJB2.0 spec. This integration between EJB and JMS has not been described yet in other books about EJB.

Chapter 9 describes the products of a couple of JMS providers.

This is a very even, complete and well written book. Contrary to what one reviewer suggests, this is not a book about SonicMQ.

If you are not born as a JMS expert ... If you hate reading dry specs ... If you need to get up to speed on JMS quickly ... If you want to know what to look/ask for when evaluating JMS ... If you learn best by playing with examples (anybody out there who doesn't?)... ... this is the book for you.

This book discusses JMS as it applies to real business applications and needs. The spec can't give you that. Invaluable if you ask me!

I really liked this book and it was very helpful for me as a reference on my desk. I am using this a lot for implementing JMS in my applications.The information is presented much more clearly than the JMS specifications.

My only recommendation would be that some UML diagrams would have been helpful to add value to the book.

So, about the book. I had hoped to find suggestions as to
how to optimize JMS throughput. Chapter 7, "Deployment Considerations" should have provided some help.
It asked more questions than it answered and offered no
specific solutions.

Overall, I got a little more out of the book than I did
reading [their] site and tutorial.

For me the book had little value. I would have been interested if it had offered some insight and/or examples into ways to set up a distributed system ( jms servers on two systems ) using various protocols. The examples and configurations discussed were the sames as those you would find at javasoft; nothing beyond a star configuration. JNDI is also a very important aspect of the JMS solution which was only thinly covered.

There seems to be a whole series of these kind of books comming out of O'Reilly. Books that are similarly disappointing are the book on threads, beans and JDBC. Again each of these books fail to take the topic beyond the specification. O'Reilly does have some very fine books, especially the Nutshell books, but some just don't have value.

This is a book with 200 pages of easy to read material that gets right to the point. It delivers basic knowledge about JMS but it is not any advanced text on the subject.

Chapter 1 present the basic concepts about Message-Oriented Middleware. Chapter two introduce you to JMS programming by the help of a simple code example. The size of the programming code feels appropriate and illustrates the concepts well. Chapter 3 dwells on the actual message. Chapter 4 and 5 takes a close look at Publish-and-Subscribe messaging respectively Point-to-Point messaging by the help of code examples. These chapters are built around two code examples that contain the necessary code for illustrating the subject, and no more.

Chapter 6 is about the important concept of guaranteed messaging. Chapter 7 tries to cover a lot of important topics, such as performance, scalability and security, but it only scratches the surface and does not give you much value. Chapter 8 cover J2EE and JMS. Again, this chapter is a bit thin and there are more to say about this subject. For instance, there is a very brief introduction to the use of message-driven beans in EJB 2.0, but does not give any example of how to solve the problem of consuming asynchronous messages in EJB 1.1.

The appendix is a quick reference guide to Java Message Service API and Messages. I found it quit useful after reading the book.

I would recommend this book as the first book to read about JMS. It gives you basic knowledge about JMS without being unnecessary wordy and provides simple and easily grasped code examples.

The material in this book is so poorly organized that I had to visit javasoft.com for a much better introduction to JMS. The author has an interesting way of presenting his ideas. He starts out with code examples without clearly explaining the JMS concepts employed in them. The code examples are so lengthy that one is left flipping back and forth between pages correlating the explanation, which is very meagre and superficial, with the code snippets. The chat application implemented by the author, instead of clarifying the concepts, only adds to the confusion. Also chapters 7,8 and 9 are somewhat peripheral to JMS programming...

I needed to learn JMS for use on a project using WebSphere MQ and MQ Integrator (formerly MQSeries and MQSeries Integrator). This book did the job. The book provides multiple bug-free sample programs starting with a simple Chat and moving on to more involved B2B examples. The examples added complexity at a pace that was right for me. It provides discussions on the use of different programming patterns explaining not just how the Java classes work, but making recommendations on how best to use them.

The book sticks to platform independent JMS (as expected) showing SonicMQ screens occasionally. I used several IBM Redbooks and the MQ product manuals to get the platform specific parts configured.