Rating: 
Summary: Decent Book on JMS
Review: If you're looking to learn JMS, then this is a decently good book to get you started. One of the best things about it is that it's not very thick and it gets to the point pretty quickly.
Rating: 
Summary: Excellent introduction to JMS
Review: In the past, programmers using Message-Oriented Middleware (MOM) were forced to learn the protocol specific to a middleware product. With the development of the Java Message Service (JMS), developers only need to learn one simple API set for any MOM system. This book is written for the experienced Java developer who wishes to quickly learn how to use the JMS API. It clearly explains and demonstrates using the JMS API with easy to follow examples. The authors start with a description of the basis of MOM systems and describe the two types of messaging systems (point-to-point and publish-and-subscribe) that are supported by JMS. They also explain why an asynchronous messaging system may have an advantage over remote procedure calls in some applications. In the next few chapters, the authors give details on how to use the JMS API to develop a simple B2B application using the two messaging systems. The authors then discuss some advanced JMS topics including guaranteed messaging, transactions, and message failures. They then cover deployment considerations (including performance, scalability, and security), and the new EJB type, the message-driven bean. The final chapter is a brief look at some of the JMS products available. Appendixes provide a quick reference to the API and detailed information about messages. At a time when publishers seem to prefer more pages to quality information, it is a pleasure to find a book that manages to provide you with all the information you need on a topic in only 220 pages. (...)
Rating: 
Summary: Complete
Review: 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.
Rating:
Summary: Lightweight introduction
Review: Java Message Service (JMS) is relatively new and this is the first book out on the subject. Others are in the offing. This book will be of more interest to Java programmers unfamiliar with message-oriented middleware (MOM) than to more knowledgeable programmers.The first chapter introduces MOM. There are two models that a JMS provider might implement -- point-to-point (or queue) and publish/subscribe messaging. The second chapter develops a simple pub/sub example, a chat room application. The third chapter discusses messages in some detail -- headers, types, and selectors. Selectors allow a receiver to be selective about which messages it's interested in receiving. Among other things, a selector can be used to match a reply to a request. Chapters 4 and 5 are devoted to pub/sub and point-to-point, respectively. For both, simple applications are developed for illustration. Chapter 6 discusses a variety of topics, for example, guaranteed messaging, that is, once-and-only-once delivery. Chapter 7 is devoted to deployment considerations, including performance and security. Chapter 7 discusses JMS in the context of J2EE and EJBs. Chapter 8 provides an overview of some JMS providers. One would do well to go to the Sun website instead, as it is more inclusive. There are appendices on the JMS API, message headers, and message properties. There is the usual smattering of misprints. Then on page 112, there is a serious error. The authors say, "Unless you are doing a synchronous request-reply, you should avoid grouping a send followed by an asynchronous receive within a transaction." Even with request-reply, you don't want to group a send followed by a receive within a transaction. The reason is simple -- deadlock. The sending application sends a request and does a receive with wait for the reply. Within a transaction, the sent request is not committed until the reply is received and so, is not visible to any potential receiving application until then. Of course, a receiving application won't send a reply until it receives a request. The result is deadlock.
Rating:
Summary: ok, but a little outdated
Review: The basics were covered, but I felt this book was a little outdated. There werent alot of books to choose from so I chose this book because it seemed like it had the most coverage.
Rating: 
Summary: Lacks clarity and organization!
Review: 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...
Rating: 
Summary: the worst CS book I have ever bought
Review: The specs from Sun cover much more details and are organized in much more natural way than the book. If you are not a total Java newbie, I would suggest reading the specs. They are dry, but they are much more useful in giving you a more complete picture of JMS, in my opinion.
Rating:
Summary: Informative, direct, and to the point
Review: This book covers all of the areas of JMS that you would ever want to know before diving into a project. It is presented in a way that is easy to read, with examples that build upon one another. It is well worth the investment in both time and money. In the true spirit of O'Reilly, it gets right to the point and doesn't include any fluff. In fact, I like it so much that I am a bit taken aback at the 2 negative reviews posted here that indicate that this is a book about SonicMQ. Indeed, one of the authors is from SonicMQ, but it seems that O'Reilly did a good job of keeping him honest. I found it to be very JMS vendor neutral. It even has a chapter at the end that lists the features of the 7 most popular vendors. The only place that it really shows SonicMQ is in a screen shot of what a "typical" administration tool would look like. Can't say that I blame him. It's only an example. I mean, what else would he use, someone else's GUI admin tool? My guess is those 2 postings were from someone associated with a competitor of SonicMQ with an axe to grind. I like the fact that it is not just for coders. Chapter 1, 6, and 7 give conceptual discussion about real world messaging issues. Great for high level managers, and coders alike.
Rating:
Summary: Excellent, practical + good background
Review: 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.
Rating:
Summary: Easy-to-read "MANUAL" to JMS
Review: This book is a fine introduction to the Java Message Service and Messaging Services in general. Like a manual, it describes simple and advanced featues of JMS in an easy-to-grasp manner. Be warned though - the book does NOT describe how to make good designs of distributed apps using JMS, nor does it tell you how to use JMS and EJB in an efficient manner (and it never claims to do so)! The book is a simple MANUAL to JMS - and as such - it's almost perfect. Then why only 4 stars? Because the book doesn't contain as much as a single UML-diagram of the JMS-API - describing the API using text and code-examples only makes it hard to grasp the (actually quite simple) overall design of the JMS API. So - if you want to understand JMS, this is a great book, but if you want to know how to bring JMS to use, in an efficient manner, this book doesn't have much to offer.
| 
