Customer Reviews

Essential Jni: Java Native Interface (Essential Java)

5 star:		(14)
4 star:		(6)
3 star:		(2)
2 star:		(3)
1 star:		(3)

 

 

Let's be clear here, after working with JNI in several capacities for the better part of a year, I know one thing: If you can avoid using JNI, you will be for the better.

JNI is unwieldy, unstable, buggy, and most of all, it creates a whole class of run time errors that will blow up your JVM. Of course, if you are smart, you will only use it for one small thing and it will work like a charm. Get out while you are ahead!

If you ignore my advice and still use this evil technology, this book is a must have since there are no good docs on using JNI anywhere. The secion regarding how to hook up a C debugger to the VM is a must read.

The book is well written and is a multi-use book that can be read before using JNI to become familiar, and then be kept on hand as you go through annoying problem after annoying problem. This book becomes a necessity reference during that tiring time.

You have been warned.

FYI, I reviewed a close-to-final draft of the book sent to me by the publisher. Some of this may be innacurate with respect to the published copy.

Sun's JNI documentation is rather dry and is really just reference material. This book is a lot more readable. It describes the JNI functions in a logical manner without just saying "here they are and here's what they do". The author also took time to explain the situations where certain functions would be more appropriate.

Some books that I've read take up many chapters hand-holding the reader by explaining how great the internet is or showing samples (with screen captures even) of how to compile source code. This book, however, gives only a brief overview of the history of JNI and then jumps right into the code...very nice!

Sample code is used appropriately. Small examples of all APIs are given, without trying to tie them into a "full application". This makes it easier to use the book as a reference. However, there were two chapters dedicated solely to some interesting example code (a Serial I/O example and writing an NT Service)...this made it easy to skip if I didn't want to read them. Nice JNI reference in the appendix.

The book seems to address both the Win32 and Unix/Sun environments equally well without making a blind assumption that the reader uses a specific one. (OS/2, MacOS, Linux, and BeOS weren't mentioned, though :-)

Easy to read and covering many areas of JNI usage. However, when one settles to write an application in earnest, the book starts feeling superficial. The reference is meager on the Sun web page and not enhanced in the book. For instance, here's a typical argument explanation: "clazz: a Java class object". No indication as to what the usage really is, just a statement of what type it is. This sort of treatment is unfortunately typical. Memory management is barely touched, and many areas are not covered. I expect to be told if a particular method manages memory or not, so I can take adequate care in my application. I expected a detailed discussion on how Java and corresponding C/C++ buffers are managed in general; How to navigate through objects to data that may not be directly available from the calling object; How to access Java static functions, like the utility libraries from native code (or a discussion why not). etc... Examples are provided and thoroughly explained in the "Guide" part of the book, but are by no means a comprehensive coverage of the usage and features of JNI.

I rate it 3 stars -- a good introduction, but not a workhorse desk reference. Good to borrow and read through to see how JNI works, but one needs more substantial information to trully write JNI code as part of an application.

While the book is not perfect, it does an excellent job at covering JNI, which is anything but straight forward. In particular, Rob Gordon gives a solid, in-depth coverage of the "ins and outs" of instantiating a JVM and calling methods on Java objects from native code. This area was especially appreciated, as other books are lacking on this subject.

This is undoubtedly the best book on JNI.The author provides examples and explanation of almost anything and everything you can do with JNI.Its also an indepth coverage into the otherwise complex field of JNI.It provides simple and accurate understanding of the concepts and even tells you the commands that you have to give to your system while working on both solaris or Windows.

I thought this was a decent book on JNI.

One reader rated the book one star because it required knowledge of C/C++. However, since the whole point of JNI is to make calls to native objects written in C++, getting upset that the whole book isn't only about Java seems kind of odd. I think the reader was also mad that he had to buy another book to learn C/C++. To me, the title was quite clear concerning the contents of the book.

I would recommend this book to anyone who wants to learn JNI. If you want to learn C or C++, buy a different book since that's not what this one's about.

JNI is not for the meek, and if you plan on using it, you will spend way to much time unless you have a book like this to clarify issues. The author tries to cover very diverse applications of JNI such as serial I/O, legacy C structure mapping issues, and running a Java program from an NT Service. Strategies such as how to design better JNI code are covered (although not as much as I would have liked). For example, keeping Java and C++ objects in sync via a mirrored approach. As with other technologies, JNI seems easy to those who feel comfortable with C++ UNTIL they have to write a non-trivial JNI application with a deadline. Although, this book does not answer all your questions, such as performance issues, and indepth user allocated memory management concerns, it does give you enough detail and coverage to make its stance as a solid JNI Handbook.

This book covers a lot of ground in less than 500 pages. The examples are well explained and address the issues head-on. Rob is clearly a better C than C++ programmer, however. I wound up rewriting most of his example code in chapter 12 to be more object-oriented. Still, a very good book.

No-nonsense, short & sweet, here's how to do JNI. I've seen many many technical books of this sort fall short of the mark, and this isn't one of them.

The book is organized by functional topic, which is *really* handy when you're neck-deep in C++ and Java. Hilites include: setting object fields and invoking object methods, working between C++ and Java types; creating and using objects; working with (or in spite of) the garbage collector; using Java exceptions in native code; working with Java strings; object and class introspection; and embedding the JVM inside of a C++ application.

Having moderate experience as a Java programmer and an extensive background in C++, I was up to speed and gunning through native method implementations in an afternoon. My primary development platform is win32, and in spite of what the editorial review says, I found every page of this book helpful.

I haven't been able to find any other JNI source that covers as many issues as this one does. I do admit that I haven't looked since this book has been doing the job so others may now. He goes through all of the different uses of JNI that one would encounter in practice giving many examples along the way. I especially liked the chapters on creating a JVM and an NT service application. If you are going to be using JNI frequently I definitely recommend this book.