Customer Reviews

Java™ and JMX: Building Manageable Systems

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

 

 

This book is divided into three parts. The first section is a history of managing computer applications and an explanation of why JMX is needed for Java applications. The second part goes into detail about JMX and the third section is about JMX applications.

The first section is an informative history of managing computer applications from mainframes to present day applications. I the reader can skip this section, if he or she just wants to understand JMX.

The second section explains Means and the tools behind JMX-based management. MBeans represent a resource that a management system will monitor and control. The MBean is the resource according to the management server. The book goes into great detail in creating and using MBeans, including the MBean notification events. In this part, as throughout the book, the explanations are clear and comprehensive. The examples fully show the user how it works and are explained completely by the authors.

This book has a serious and comprehensive style. The authors assume that the reader has a fairly extensive knowledge of Java. This book is an excellent introduction to JMX and is comprehensive in its coverage of all topics related to JMX. I would recommend this book for anyone interested in learning about JMX.

Unlike "JMX in Action" from Manning, this book goes beyond the How To of JMX.
It introduces the reader to the fundamental problems of systems management, before jumping into concrete implementations.
It explains the history of the industry from the days when hundreds of people shared one mainframe and sys-admin was the same as god, to the present days when everyone has access to hundreds of computers.
It also gives an overview of the numerous system management standards and explains why some of them were successful while others were not.
Before I got to the JMX chapters I understood how the veterans in the industry with decades of experience distilled the scope of systems management to a few basic concepts that define it.
It helped me make a better choice when thinking about which parts of an application should be manageable.
Very strong book.
Just be aware that it is not a very fun reading. The book uses a tight, dry and fast style. You better be serious about it before turning the front page.

This is an excellent book that truly helps understand the JMX architecture and it's practical use in managing a distributed system. The chapters are very well thought-out. The book methodically ensures that you will understand every aspect of JMX and how you can leverage it in the real world. After reading this book you'll have a complete understanding of what each component of the JMX specification does and will understand what all your options are as well as the pros and cons of each option. Each subject is presented with authority. The presentation is not dumbed-down at all, yet very clear, logically organized and concise.

I have read Manning's "JMX in Action". While it had a lot of code examples, and explored the JMX api in-depth, I felt I did not understand JMX overall any more than when I started reading it. I was amazed how a few hours with "Java and JMX" were able to give me a complete understanding. If you are deciding between these two books, I really think there's no comparison, get the "Java and JMX", you will not regret it.

The book provides an excellent introduction to JMX and gives an in-depth coverage to the API. I think authors should now publish a new edition to this book reflecting new JMX versions, MXBean, jconsole, inclusion of JMX in Java SE etc. The example application (Apache WebServer Monitoring) can be replaced by some easier to understand application. Another nice to have chapter could be the monitoring of Spring based applications showing mix of AOP and JMX that architects are using these days.

Remember when java burst onto the scene on 1996, and you could write cool applets that showed animations on a web page? Well things have progressed vastly since then, and especially after the dotcom crash, being essential is far more important than being cool. The emphasis with java has shifted from towards backend, web server-type applications, when you have to interact with legacy databases and management tools. The problem with the latter is that if you are writing a java application that is to be controlled by some management level software, this latter item could be furnished by several companies. It is expensive to customise your code for each management package; but not to do so may severely restrict your sales.

JMX, Java Management Extensions, arose to solve this puzzle. It is still fairly new, and not many java programmers may be familiar with it. If so, this new book [2003 vintage] will help educate you. The authors point out a simple analogy that may clarify. Shortly after java was introduced, there was a need to let java programs access data in databases made by various
vendors. The solution was an industry standard API, called JDBC. Each database vendor wrote an implementation of this API, which was hence called a JDBC driver. This let java programmers program to that interface and ignore any lower level details.

So if you can understand that, you can understand JMX. The difference is that here your java application will be controlled by some management software, whereas with JDBC, your java program would have been the controlling entity.

The bulk of the book goes into the details of the JMX API. [Ok, it may not be literally an application programmable interface, but conceptually you can think of it that way.] The exposition is straightforward and logical.

A nice resource for the aspiring JMX developer.