5 comments about Java Web Services.

1. The content in this book is a little dated. For a current book on Web Services check out either the Wiley book (Developing Java Web Services) or my favorite Java Web Services Architecture.



2. Not that dated, you will get the background that is behind all the hype and you will get some hands on. Not a first choice but it is a solid review and a book I still keep on my desk. Get this and of course one of the newer titles. The new ones may be hyping something that isn't going to happen, at least with this one you will find most of the topics still are the cornerstones of web services. There is gold in them there hills, and those hills are strewn with books discarded too soon as old. Many explain things very well and offer knowledge. Nice book.



3. This book covers the topic of web services, primarily from a Java perspective. It assumes a familiarity with Java and XML so as to be able to follow the code examples. The chapters are as follows: Welcome To Web Services, Inside The Composite Computing Model, SOAP: The Cornerstone Of Interoperability, SOAP-RPC, SOAP-Faults, and Misunderstandings, Web Services Description Language, UDDI: Universal Description, Discovery, and Integration, JAX-RPC and JAXM, J2EE and Web Services, Web Services Interoperability, and Web Services Security.

   Review
   If you read the chapter headings and say "What does THAT mean?", then you probably have a reasonability good idea as to whether this book is for you. As stated in the preface, this is not a "For Dummies" treatment of web services. While it covers all the different technologies that make up web services, it does it at a pretty high level of detail with a lot of code samples in Java.

   The good thing here is that many of the examples are given using the Apache Tomcat server as the mechanism for processing the request. This is great in that you can download that software for free from the Apache site. This book doesn't go into detail as to how Tomcat is set up and configured, however. You need to work through that on your own. Once you get to that point, you can use Tomcat to play with the examples that are used throughout the book. While they can look complex and intimidating, you can learn a lot from them.

   As a Notes/Domino developer, I learned a lot by reading the book. Am I ready to start developing web services? Not hardly. But I do understand more of the concepts behind how they work. Since web services often use servlets to process requests, Notes/Domino 5 doesn't fit the traditional picture of the technology. But since web services usually involve SOAP XML statements sent to a server, there's no reason you couldn't program a web service in Domino as a web agent that runs when a user submits a web page or runs a URL that activates a server agent. The processing is done and then returned to the client as an XML page. Once you read and digest the basic concepts behind it all, it all starts to come together.

   Conclusion
   If you are a Notes/Domino developer who is trying to understand "web services", this book could be useful. The book gets progressively more complex and detailed, so you may find yourself skimming at the end. If you are to the point of being ready to run an implementation of a servlet and SOAP engine (like Tomcat), this book will help you get started with your understanding of web services.




4. I wish I could recommend a better introduction to Java Web Services. David Chappell usually does a good job at explaining new technologies in simplified form; however, he falls short with this one. It comes very close to being a step-by-step, build-up tutorial but falls short. If you already know SOAP, perhaps coming from the .NET world and you just need to make the right connections in the Java world, then this would be a good book for you. However, if you don't know SOAP and you're looking for a thorough understanding of what's going on under the covers before you move on to advanced APIs, then this is not your best bet. Actually, I'm not sure what is. I started writing such a tutorial myself but got distracted by other projects. However, this book is solidly average, nothing necessary wrong with that, and if you can find it at a good discount it's a decent buy.



5. I bought this, hoping to be able to use it on a web services project I'm doing.
   
   I find it's completely out of date. Both Sun's JWSDP and Apache Axis have moved on since this was written, and you'll get better information from their websites than you'll get from this book.
   
   Don't bother with it.

5 comments about Beginning JavaServer Pages.

1. This is a hefty tome weighing in at 1262 pages. Wrox have a sound reputation for producing excellent programming titles, for programmers by programmers, and this latest offering does not disappoint.
   
   From the onset, it is clearly an outstanding work with a solid emphasis on writing code properly. The book has lucid sections devoted to design patterns, testing, model-view architectures and many other important considerations in good software engineering. This is not just a "sequence, selection, repetition" work but one which distills obvious years of experience. Any reader can have confidence they will be not just a JavaServer Page (JSP) code cutter after finishing, but a good, professional, developer with a mastery of principles than transgress language boundaries.
   
   The book is divided into four broad sections. Part one covers JSP fundamentals. Part two builds on this putting the JSP language knowledge into the framework of modern Web server software development, including coverage of servlets, security, performance and database integration. Part three puts it all together and shows how to build two complete real-world applications: a personalised portal, and an updateable, data-driven shopping cart site. Part IV concludes with appendices and exercise answers.
   
   The book is not simply a standalone volume; Wrox have a hierarchy of Java titles which progress from beginning Java and JavaServer Pages through to advanced J2EE development. That said, this book can be entirely appreciated on its own and is comprehensive and complete in its coverage of JSP. It does not make any assumption of previous programming experience, but at the same time does not bog experienced programmers down with basic fundamentals.
   
   The price is surprisingly reasonable for a book of this quality and size and consequently it is an indispensable purchase for anyone who wishes to develop server-side JSP apps.



2. This book is the perfect complement to Marty Hall's Core Servlets and JavaServer Pages Vol. 1...."You wont be dissapointed with this book since almost everything is covered here from Servlets,JNDI,JDBC,JAXP and Java Mail....Plus the authors writing is absolutely beginner-friendly...If you want to learn the basics of java however this book is not for you...but then the power of Java really shines on Server-side programming...and plus the J2EE architecture is centered on JSP technology...I would recommend this to anyone who wishes to dwell into web-services programming...One downside i found however was the repetition of several topics such as XML and XSLT however provided with the fact that this is the culmination of several authors work i think with that said the repetition of topics can be forgiven...hell if ya already know the stuff from chapter 6 and its repeated on chapter 8 hell skip it...its that simple....highly recommended for JSP beginners and gurus alike



3. I did learn a lot about JSP from this book. I learned how it works and the history of it. I did not, however, learn how to write JSP. This book touts hand-ons but their idea of hands-on is pasting several pages of code in the book and telling you to write it verbatim in your code. It goes over some good tools (such as Ant) but never mentions an IDE or what the best way to go about starting a project is. For the most part it moved very slowly and repeated its self a lot. The book is about twice as long as it needs to be. I do feel like I learned from this book but overall I don't think it was worth my time.



4. The book is extremly good, it explain everything about JSP and other new technologies, i really recomend it



5. The word "Beginning" in the title is optimistic at best. I would not recommend this book for someone new to JSP. I've made it through 14 chapters, and now I'm going to drop this one and find something else. The last several chapters have been extremely frustrating. Too many examples don't work, and many things are not well explained. I've had to find other sources such as java.sun.com to find good explanations for things that are quickly passed over in this book. And I'm a certified J2SE programmer, so I'm not exactly a beginner.
   
   The only IDE that has been mentioned so far is NetBeans 3.6. That's hopelessly out of date. The order of the chapters doesn't even make sense. An exercise in chapter 5 wants you to create and deploy an application, but nothing is mentioned about deployment until chapter 16!
   
   And forget about asking questions on the P2P forums at the wrox website. They are effectively abandoned.
   
   Overall, way too much reading for poor explanations, and poor exercises. You can find something better.

1 comments about Starting Out with Java: From Control Structures through Data Structures.

1. If you're new to programming and are considering which book to buy, it is essential to consider that many good books (such as Head First Java, Core Java, Just Java, and The Java Tutorial) are meant for experienced programmers who need insight into Java's more complicated concepts. These aren't textbooks for students. But Tony Gaddis's books are, and this book is no exception; in fact, it is the best Java textbook I have ever bought. This book is loaded with examples, exercises, case studies, and projects. It has everything from loops to linked lists, and it does not neglect GUIs by placing GUI topics to an optional section at the end of the chapter or in the last chapters of the book. This book will also serve you well as a reference book and as preparation for the SCJP certificate. I have also bought Gaddis's Starting Out with C++ From Control Structures through Objects, 5th Edition, and I am quite willing to recommend, sight unseen, any book that Gaddis writes.

5 comments about Graphic Java 2, Volume 2, Swing (3rd Edition) (Sun Microsystems Press Java Series) (2 Book Set).

1. Mr. Geary has produced a wonderfully comprehensive guide to Java Swing, patiently explaining the advantages and disadvantages of each component, along with the theory behind Swing's framework.
   Every piece of software was written to solve a problem. If a programmer really wants to understand the limitations (i.e. how to use it effectively) of software, he/she must understand the problem it was developed to solve. Mr. Geary goes the extra step in his book to give the theory/history/reasoning behind Swing, as well as, providing examples you can actually use in your code. Congratulations on an outstanding job!!



2. This book is very comprehensive and is a must for any serious Swing developer. I have found it as a good reference for all sorts of examples and also in a method lookup like way.



3. That is all, pure java. Simple, organized, interfaced, estructured, conceptual and objective point of view of reality. Some examples, lots of them, really, some descriptions of classes, all of swing JFC, really, and that's all folks. No more, no less. But that's the best, it's a reference of swing, "thousand and more" pages reference, but clear reference. A must if you're interested in collecting java muscle books.

   Nice cover desing. Strong, doesn't break easily. Sorry ;)




4. Like a fine movie, this book is still very useful even as the language advances. A wonderful reference I still find myself reaching for it several times a week for parts of the GUI that I don't reach into that often. Considering that I use the Eclipse front-end I do all of my GUI coding by hand (that and most GUI builders put out some really terrible code), so maybe I am a bit atypical in this regard.



5. I wish I had bought this book first...I found this book to be a great read; fun, entertaining, and structered in a way that answered my questions before I could ask them. This is the only Swing reference I ever use besides web searches. If I'm picking up a new topic, my first step is to see if this author has a book!

2 comments about Professional Java JDK 6 Edition.

1. The book provide really helpful for you if you are trying to know more about Java after you have done it. It provides a lot of examples for doing one thing in different ways.



2. Professional Java attempts to do something I don't think any one book can do well, which is to say something useful on just about every topic. This book's sections include: important additions/changes to JDK 5; a whirlwind tour of project methodologies; design patterns; build tools; persistence tools; UIs; web applications; JNI; EJB 3; SOA; security; and packaging and deployment. The book wants to be a "one-stop shop," and that's fine. After reading through most of the sections and skimming some, however, I'm not sure what the profile of the target shopper might be.
   
   The topic coverage varies wildly from section to section, in the writing style (and quality) and in the effectiveness of sample code to illustrates a point. Too often the descriptions are both verbose and phrased in the passive voice. Some code samples seem like proof-of-concept sketches of a feature or library facility, rather than a compelling example of its use. Still other samples seem full of boilerplate code that speeds up the page-turning but isn't illuminating. And sometimes the text changes its diction strangely; the style changes from a general description to a "follow-along" activity without warning. Some sentences sound as if the author left them in as a reminder to complete a task.
   
   The result is a thick book that, for me, is sometimes tedious or exhausting to read. I think it would have been helpful to give author credit by chapter, if only to know the presentation might change significantly. Also, a concerted effort at paring things down, and keeping the diction clear and active, would help make it more readable and something worth referencing.
   
   As mentioned, the topic coverage is quite broad. This book might come in handy to someone who just needs many topics in one book. So long as you don't need your one reference also for getting started, this book could be a useful collection.

5 comments about The Definitive Guide to SWT and JFACE.

1. This is overall an excellent introduction to SWT and JFace. After working with the technology for over 2 years I can say that it would have been a great help to have this book back then. The book's layout was well thought out. My only wish is that they put out a follow up book covering some of the more advanced topics like Events, Embedding Swing components, Packaging and Distributing SWT/JFace applications (including using JWS), using Native code. Plus, even though is Java covering some of the things that can be done with ActiveX controls would be a plus.



2. Much of the beginning chapters in SWT are simply API listings - WORTHLESS! I've got those online...don't need them in a book, especially since they are not as complete as the JavaDocs. Otherwise, not bad. I'm looking for better...



3. Having being treated to a text called Windows Forms Programming for C# by Chris Sells in late 2004, and considering that's pretty much the closest book in spirit in terms of covering a high-level Windowing API and is relatively well-known, I'll go right ahead and use that as a metric:
   
   I am surprised to find no coverage of SWT and Java 1.5's threading abilities. I wanted to see a coverage of how to handle long-running worker threads that must call delegates that run on the UI-thread (like a web services caller threaad telling the gui-thread to update the progress update bar to show 75% completed). I wanted to see coverage on how to send events information back and forth between GUI thread and the worker threads. It's one of my favorite chapter in Sells' book because without it it is very difficult to write a responsive app. This is criticial in this day and age with the decent amount of web services and distributed computing being used in Intranets and Internets. If Harris and Warner are willing to write an extra chapter on this very topic, I would be greatly in their debt. We are all waiting for this chapter! I guess some of you will say, wait for Doug Lea's next book, but I trust Harris/Warner to get to the point faster and better--and stay on topic (I am not sure if Doug Lea would bother with SWT). I am hoping there's an answer to this, because I need to use this asap.
   
   There are some other surprises I find distasteful: data access and binding of data recordsets to grids are no where to be found.
   
   These are the main reasons why this book gets a four star. Because people like me are spoiled.
   
   Anyway, back to the book review:
   
   Real-world cross-platform development is a tough subject. If you ask most people, they'll relunctantly say the best way to go about it is to write platform neutral c++ model/controller code and write the view code in Qt or Gtk/MFC or WinForms/Carbon or Cocoa. Nasty.
   
   It goes without saying most small development shops simply can't budget serious competence in one, let alone three major GUI frameworks. This is not counting all the trouble you have to go through to evaluate count-less so-so [for one reason or another] libraries (wxWidget, MainWin, Swing, OpenStep API, Flash, Mozilla) just to arrive at the point where you can clearly say aha, I really want MFC/Carbon/Qt after all.
   [And let's not even get into strictly system programming libraries, for which there are several dozens on the sourceforge galaxy alone.]. So for light work, where you aren't trying to please 500 million users right away (Internet Explorer, Outlook Express) or even 200,000--you really want something like Java 1.5+SWT:
   
   > One productive language.
   
   > One well-supported effort to map a common gui api to all major windowing systems while preserving native looks.
   
   > A quick build that produces three executables. One for RedHat Linux. One for Mac OS X. One for Windows NT 5+.
   
   Which is why I am really happy Sun and IBM is trying so hard to make this option happen. I build small softwares for a relatively small audience. With IBM's contribution of SWT, all we need now is a good text that cover it thoroughly--from the perspective of developers--not the library writers. The Definitive Guide to SWT and JFace gives you just that.
   
   At times, I can see how some of the other reviewers might say, "It's just table listings rehashing documentations", and if you compare this book to Chris Sells' book you may wonder the same thing--but I think it's still an excellent try and the authors add something to the docs. I'll point out a few examples:
   
   * In the "Selecting Files for Open and Save" they went out of their way to write the correct version of how to handle over-writing an existing file. Hey, just imagine if the authors said nothing... ;-)
   
   * Throughout the book they document what the behavior will be if you did something undocumented: they'll mention when you shouldn't subclass SWT; they post questions to the eclipse group to clarify some of the bad decisions that had to be made and they tell us what we should do about it.
   
   * They explore some patterns they expect real world programmers will likely try (like Decorations, which is like a half-implementation of MDI), and warn you ahead of time what you can expect to find or even whether you should use it.
   
   The best part about them adding a bit of details is that you'll likely dig through the MSDN with Sell's book (which is not a bad thing), but you'll probably have everything at your finger-tips with Harris/Warner--so is it a bit wordy? Is it too referency? Maybe--see for yourself. :-)
   
   This is a great book, and I wouldn't hesitate recommending it. It's a key to a world of cheaper better cross-platform development--walk--no run to your bookstore and get it!



4. if you are looking for something to walk you through widget by widget..holding your hand this is your book . Excellent reference and very clear structure.
   Good to have by your desk when you need to look up something and dont like reading javadocs from the source ...



5. This book introduces SWT and JFace in details and with good example codes, which helps me doing my own projects greatly. I have "Swt JFace In Action" book too, which is not as useful.

5 comments about JUnit Recipes: Practical Methods for Programmer Testing.

1. This review also appears on StickyMinds at http://www.stickyminds.com/s.asp?F=S767_BOOK_4
   
   JUnit Recipes is a comprehensive tome of practical methods and techniques for the opensource JUnit tool to develop automated unit-tests for Java/J2EE applications. The book is split into four parts: Building Blocks, Testing J2EE, Additional JUnit Techniques, and Appendices. The Building Blocks cover the basics of using JUnit to create basic tests, organize and manage test suites and test data, running JUnit tests and reporting the results. It even includes a section on troubleshooting. Testing J2EE covers XML, JDBC, EJB, web components (including JSPs), and J2EE applications. Additional techniques include testing some well known design patterns, using JUnit add-ons and JUnit libraries (like GSBase). The Appendices include complete solutions (including code of course), some short and sweet essays on testing, and a modest recommended reading list.
   
   The organization of the book flows very logically and the writing style is very clear and easy to follow. Along the way many insights into important design principles and testing techniques are revealed: the reader will learn about the "Hollywood principle", the Open-Closed principle, design patterns, POJOs, Mock Objects, Private and Parameterized Test-Cases, Abstract Test-Cases, Self-Shunts, and Spys. The book's coverage is very comprehensive and touches on many other popular Java/Enterprise projects and frameworks such as Struts, JBOSS, Prevayler, XDoclet, Tomcat, XPath, XMLUnit, HTTPUnit, Ant, Jakarta, and others.
   
   Even though JUnit is often associated with "Agile" development and much of the wisdom apparent in the book applies to agile Java development, the book is useful to any Java developer on any Java project (agile or otherwise). The book also goes into considerable detail, with working code examples, to spell out exactly how to perform and apply the techniques it describes.
   
   The book's primary audience is Java developers. Java Tester's will still find some good nuggets of information but it's quite clear that Java programmers and developers are the target audience. This isn't some high-level theoretical book mostly of concepts and ideas. This is an imminently pragmatic guide that not only conveys a great deal of highly practical wisdom but also clearly and comprehensively walks you through the explanations and the code to accomplish and apply the techniques it describes. The book is also not a "How To" for coming up-to-speed on setting up and running JUnit.
   
   Another book from the same publisher, "JUnit in Action" is a great overview on learning more about the basics of running and using JUnit and on using JUnit to tackle a number of basic challenges with unit-testing Java and J2EE code. JUnit Recipes has some overlapping material but pretty much "picks up" where "JUnit in Action" leaves off, and JUnit Recipes goes into much more breadth and depth of coverage of JUnit methods, practices and techniques and use with other Java projects and frameworks.
   
   I would say JUnit Recipes should probably be required reading for anyone attempting to use Java, J2EE and JUnit in the real-world.



2. This isn't necessarily the best introduction for absolute beginners (I would recommend /Pragmatic Unit Testing/ for that), but it is required reading for server-side Java, as most other reviewers have pointed out. But it's more than that--it's one of those rare computer books that transcends its subject matter. Why? Because it can make you a better programmer. While some of the credit can rightly be given to unit testing and Test-Driven Development in general, Rainsberger's book makes you /see/ better ways to write and refactor your code. The breadth and depth of examples is astonishing--he convincingly shatters "but it's too hard to test that" arguments with well-researched, non-trivial examples. In fact, I'd say that this is almost a better J2EE tutorial than most books about J2EE proper.
   
   I'm withholding a star for one reason: the book doesn't cover GUI testing tools like Jemmy, JFCUnit, or Abbot/Costello. These JUnit extensions are ripe for a book with this depth; it's just too bad that this couldn't be that book. Other than that, I find that I turn to Rainsberger's book far more often than any other testing book or online reference.



3. Rainsberger does a very good job of detailing the techniques to unit test difficult code; including xml, ejb, servlets, jsps etc.



4. This is a great book. It is directed at users of JUnit, the Java unit testing framework. But in my mind the book gives sound advice for solving your programming problems in general, not just for Java or JUnit testing. It stresses the importance of unit testing, programming to interfaces instead of implementations and just simple common sense. The author is clearly passionate about his field and extremely experiences. The combination of enthusiasm and experience comes through on every page.



5. This is a readable, practical, and deep book. It's one of those books which teaches or refreshes Java and OO theory and practice as you read. I am also reading it for pleasure!

5 comments about The J2EE Architect's Handbook.

1. This book covers many topics, unfortunately it does not go into great detail on any of them. I don't know what the author was trying to do with this book, but I do know that this is not the new J2EE bible as some of the other reviewers have stated. Some of the topics covered have nothing to do with J2EE, they are project management topics.
   
   If you are looking for a real J2EE book look elsewhere.



2. I'm a Junior J2EE Technical Architect and I just finish reading your book. It's really interesting and instructive. It helps me a lot on my project planning.



3. I develop applications using J2EE and .NET. I found that most concepts found in this book are equally applicable to the .NET arena as well. Good work.



4. This book has outstanding breadth of information for system architecture. Some details are quite basic, while others are quite indepth. Overall though, what's most important is that the book is very well written and serves its purpose well. It has many excellent strategies, along with a comprehensive feature list of most J2EE projects.
   
   Definately a 5 star.



5. I received the book when expected and in perfect conditions. Very interesting book for a very reasonable price.

5 comments about MySQL and Java Developer's Guide.

1. I have bought this book because I had expected to find there some more advanced hints and tricks, especially about performance tuning and bottlenecks of Java and MySQL applications. Unfortunatelly, this book only covers the very basic problematics. It is a good kickstart for beginners, but only for them. Experienced developers should pick a general J2EE book instead.



2. I have not come across the errors in this book that some other reviewers have talked about and the code I wrote using info from this book works. My only bad words about this book are that the sections were not really ordered in with any logic, and were not very long. This was Ok though because they give enough information and coresponding well explained code examples to get the job done. I thought I was in trouble because the first half of the book didnt talk about using java and mysql on a web page but half way through they talked about servlets. With this book you can code a three tier web application that runs a store driven from your mySQL DB or you can write stand alone apps with mySQL functionality. In short this book is effective where it counts.



3. This book is fantastic, it teach step by step.
   I hope you can buy this book if you are a beginner in MySQL but if you have some level in java languaje.
   -------------------------------------------------------------
   THIS ARE THE CHAPTER
   
   1. AN OVERVIEW OF MYSQL
   2. JDBC AND CONNECTOR/J
   3. WORKING WITH MYSQL SQL
   4. INSTALLING MYSQL, JAVA, AND CONNECTOR/J
   5. USING JDBC WITH JAVA APPLICATIONS AND APPLETS
   6. ACHIEVING ADVANCED CONNECTOR/J FUNCTIONALITY WITH SERVLETS
   7. MYSQL TYPE MAPPING
   8. TRANSACTIONS AND TABLE LOCKING WITH CONNECTOR/J
   9. USING METADATA
   10.CONNECTION POOLING WITH CONNECTOR/J
   11.EJBS WITH MYSQL
   12.BUILDING A GENERAL INTERFACE FOR MYSQL
   13.DATABASE ADMINISTRATION
   14.PERFORMANCE AND TUNING
   
   APENDIX A -> MYSQL DEVELOPMENT AND TESTE ENVIRONMENTS
   APENDIX B -> DATABASES AND TABLES
   APENDIX C -> THE JDBC API AND CONNECTOR/J
   APENDIX D -> MYSQL FUNCTIONS AND OPERATORS
   APENDIX E -> CONNECTOR/J LATE-BREAKING ADDITIONS
   
   ------------------------------------------------------
   
   EXCELLENT BOOK.
   THANK YOU MARK MATTHEWS
   JIM COLE
   JOSEPH D. GRADECKI



4. I'd never done anything with databases, and SQL was an almost total mystery. So when I decided it was time to "modernize" a tracking tool I'd developed for my team using Perl and a simple flat file "database", I knew it was the opportunity I'd been waiting for to learn something useful and new: database programming. And while there are a lot of ways to develop a database application, I've always kinda wanted to learn Java.
   
   A search for references on databases and Java didn't turn up a lot of hits that looked useful, and this book was about the only serious or substantial work focusing on my need. I bought it with some trepidation; but found it straightforward, approachable, and reasonably comprehensive. Armed with this book plus the MySQL PDF manual and Sun's online Java reference for additional details, I forged ahead and in a couple of weeks of "spare time" programming, I've designed a reasonable and usable database schema, implemented it, and populated my database with data recovered from various project archives. My tool's "not all there" yet, but I expect this book will remain relevant as I expand my humble command line tool into a servlet and GUI... it has good simple examples of all that, too.
   
   I wouldn't lay claims to being an expert database or Java programmer, but it's pretty cool to be able to say this book helped me become competent in just a few weeks of part-time development.



5. I'm currently enrolled in an Undergraduate Course in Relational Database Systems. I was getting tired of reading incomplete tutorials around the internet on how to use JDBC and MySQL effectively so I bought this book bought last week on Amazon Marketplace. It was ridiculously cheap (About $3), but after seeing how useful it is, I definitely would've paid the regular price. One of the authors, Mark Matthews, actually wrote the Connector/J driver for MySql!
   
   -This book is a tutorial, NOT a reference.
   -All of the code and examples used in the book are available online so you don't need to waste hours retyping code to get the feel of it.
   -The book assumes you are somewhat competent in Java and goes into applets, beans, and EJBs, but I think someone who knows C++ and really understands OOP will be able to manage alright.
   
   Good luck!

5 comments about Java Reflection in Action (In Action series).

1. This book presents an unusual but surprisingly important Java API, the one that underlies component technologies, dynamic loading, and more. Reflection isn't just for ubergeeks writing debuggers and similarly gutsy applications, it can help with everyday tasks of many kinds. The Formans show how, using many examples and a friendly but technically dense style.
   
   The book covers all the basics. It starts with the whole idea of metaprogramming, writing programs about programs. Maybe it sounds involuted, but the first two chapters show how it works for handling the basic features of an application, the methods and fields. The next topics cover object creation: first, objects of classes that already exist, then classes created on the fly using Java's Proxy mechanism. A little later, they cover class loaders and custom loaders in the clearest, best-motivated discussion I've seen anywhere. The chapter on Design Patterns is, as in so many books, somewhat perfunctory. I've used reflection to analyze DPs in running programs, so I found that chapter disappointing. The last chapter begs to be rewritten. This book was in production when Java 5 was on the horizon, but issued after Java 5 hit the streets. Java 5 introduced many new features such as annotation, and new reflective APIs to support them. That last chapter looks forward to features that have since become real - not a fault of the authors', but enough reason for a second edition.
   
   There are some real problems in this book, though. A minor one is that the reflection API isn't actually laid out entire anywhere in the discussion, but JavaDoc will take care of that for you. More importantly, serialization is a crucial part of the component technologies that reflection supports. This book largely disregards the standard APIs and SPIs in favor of an ad hoc, roll-your-own approach. Trust me, that's a bad idea. See Halloway's aging 'Component Development' book or old editions of 'Java in a Nutshell' for much more complete treatment of real serialization. Part of the problem in this treatment of serialization is its weak discussion of the inheritance hierarchy: when serializing a subclass, you have access to only half of an object. The superclass[es] is[are] the other half, and may have private data that the subclass can't serialize on its own. This weakness recurs in an otherwise interesting discussion on checking of invariants. The approach in this book seems to forget that the subclass invariants are only half of the object invariants, and the superclass is not handled. Also, as Szyperski notes, invariants interact subtly with callbacks, a discussion conspicuous by its absence.
   
   This is an advanced book that Java newbies might not benefit from, and I don't mean that as a criticism. It's for experienced programmers with big, complex problems. It's for dynamic, extensible systems, the kind that we all want to work on. Even though it's Java-based, it's for anyone programming in any reflective language, at least until your language gets its own version of this book. Despite some significant problems, I recommend this book highly.
   
   //wiredweird



2. If, for any reason I had to keep only 10 Java books, this one would have made this list. It's consise, up to the point and covers not only Java reflection, but many other important subjects such as class loaders, design patterns, design with interfaces, proxies, et al.
   
   I'm a technical writer myself and follow the simple rule: "the book/article is ready when you can't remove anything from it". The authors have managed to cover complicated topics in a 250-page book that has nothing to remove.



3. Java Reflection is an extremely powerful API that most modern frameworks like Spring, Hibernate, XFire, JUnit etc., use as its core enabling technology. We all use these frameworks for our applications, but never really bothered to see how the framework achieves certain things that it does.
   
   This might be because we think reflection
   1. is complex --> maybe it is, but do you think that it should stop you when it can cater more elegant/flexible/reusable code.
   2. is an advanced topic --> maybe it is, that is why we are learning this after learning the basics first.
   3. performs poorly --> Latest versions of java has considerably improved reflection API's performance. Also, there is an entire chapter dedicated to performance in this book.
   4. for framework programmers only --> Not any more
   5. is not necessary --> It is not necessary until you learn it. Once you learn it, you will wonder how you even lived without it.
   
   Today, Reflection is being used even for application requirements such as
   1. Flexible and re-usable code
   2. Implementing cross-cutting concerns
   3. Validation
   4. Dynamic addition/modification of functionality... and much more...
   
   In this book, the Foremans do an excellent job of preaching the advantages of using reflection. They are pragmatic in that, they keep you adviced that reflection is a magic-bullet only when used for the right purposes. The chapters are well organized and starts with the basics and goes all the way to the most advanced concepts.
   
   The authors start with a simple scenario where reflection could be useful. Using this scenario they teach the basics of Class and Method objects, how to find the class of an object at runtime, how to invoke a method on that object etc. The next couple of chapters takes "Serialization of Java objects to XML" as the use-case and explains the concepts of accessing fields reflectively, dynamic class loading, dynamic object construction etc. Moving onto the advanced concepts, the author takes you through a tour of dynamic proxies, custom classloaders, call stack introspection, performance metrics etc.
   
   At this point, the authors stop to point out the shortcomings of the java reflection API and show you how to use Code-Generation technique to work around those limitations.
   
   Finally, the authors give a sneak-peek at java 5 and how it is going to change the reflection API.
   
   I have a couple of suggestions for this book though
   1. This book needs a java 5 update
   2. Java beans API could have been discussed at a shallow level atleast. Though java beans does not belong to the reflection api, it is <<-- well -->> indirectly related.
   
   Overall, I found this book easy to read, rich in content, pragmatic in advice and i highly recommend it to any "moderate to experienced" java developer who wants to construct code that speaks for itself.



4. This book starts great, brilliant and clear, and then crushes and burns to a cold, dark, inglorious end. The first six chapters are very well written and informative. Thanks to them some pieces that were still missing from my java puzzle clicked into place nicely. Any reasonably experienced java programmer will find interesting material on the basics of reflection, manipulating fields and methods, dynamic object construction, stack trace reflection and the uses of a dynamic proxy.
   I liked the choice of introducing new material with a very simple and self contained example before attempting a more complex "put it all together" example. Also, yes, the examples are quite contrieved, but that can be justified because while it's true that little bits and pieces of the reflection API can be useful in most programs, it's definitely hard to come up with an example program that gains real advantage by using ALL of the reflection API.
   Starting with chapter 7 on code generation, this book takes the very sorry road of an overly academical, obscure style that is only about introducing unnecessary complications. My bet is the real reason for introducing these last chapters was to fatten up a book that even like that is quite slim. In fact it's certainly not easy to produce a 200+ pages book on reflection alone, but still the author's would have been better off introducing more examples, or even treating another subject besides reflection, than introducing these bogus chapters. Still a worthy buy though, for a java programmer that has digested the basics and is curious to find out what is possible with the apparently arcane features of reflection.



5. I first ran across the concept of reflection in Java in Cornell's Core Java book back when I was first learning the Java programming language in 1998. However, that book just treated reflection as a set of cute pet tricks of which Java is capable. Interested in a particular aspect of a class? Use this or that method and inquire. Only thing was, as a developer of code and not of tools, I found this aspect of Java interesting but not particularly useful. This book gave me a whole new respect for the tool of reflection. In a large multimedia application, my main program was going through a long series of if statements and looking for matching strings and then calling the matching sub-application. It worked, but it was large, clunky, and not very maintainable. I read this book and got the idea for a much more elegant solution. Rather than enumerate each class, I build the class name of the object I need from my list of options to construct and instantiate using reflection at runtime. Mind you, I didn't read or buy this book with that solution in mind, the author was just so clear in talking about the usefulness of reflection that the idea came to me. That's just one of the uses I've found for reflection in reading this book. Trust me, you don't have to be a software tool developer to get good mileage from it. I highly recommend it. I list the table of contents just because the product description does not have it listed:
   
   1 A few basics 1
   2 Accessing fields reflectively 27
   3 Dynamic loading and reflective construction 49
   4 Using Java's dynamic proxy 73
   5 Call stack introspection 107
   6 Using the class loader 121
   7 Reflective code generation 143
   8 Design patterns 179
   9 Evaluating performance 207
   10 Reflecting on the future 225
   appendix A Reflection and metaobject protocols 241
   appendix B Handling compilation errors in the "Hello world!" program 253
   appendix C UML 256
   
   I subtract one star because this book was written before Java 1.5 came out, and new features have been added. However, it is still a good place to start when you want to see just what reflection in Java can do for you.