Java and JMX: Building Manageable Systems
| 1969-12-31 00:00:00 | | 0 | Java
Comprehensive coverage-from APIs, programming techniques, and pitfalls, to the integration of JMX applications into J2EE and Web services. The definitive JMX reference. Softcover.
User review
Excellent Resource
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.
User review
Not just a cookbook
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.
User review
Easy to understand
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.