Oracle JDeveloper 11gR2 Cookbook: Using JDeveloper to build ADF applications is a lot more straightforward when you learn through practical recipes. This book has over 85 of them to take you beyond the basics and raise your knowledge to a new level.

First, the author has discussed issues that you need to address in the early design and architectural phases of the project: * Modularize your application o Break up the application in multiple workspaces o Divide data model into appropriate application modules o Avoid circular dependencies use tools such as Dependency Finder * Make your application easy to extend o For example, allow the ability to extend the framework's base classes early on in the development process * Set up logging with the right logging framework o Choose ODL (Oracle Diagnostics Logging) for its tight integration with WebLogic and JDeveloper. * Use page template to ensure that pages throughout the application are consistent, and provide a familiar look and feel to the end user * Customize the exception error message for your application * Use a generic backing bean actions framework to encapsulate common functionality for common JSF page actionsAfter laying out the foundation, the author then expand the scope of discussion vertically and horizontally.Vertically, the book covers different layers of the ADF's MVC architecture and various components in each layer. Horizontally, it discusses different supporting frameworks or technologies which are used to help you create a successful end-to-end enterprise application: * IDE: JDeveloper * Integration Framework: Hudson * Unit Testing Framework: JUnit * Deployment Framework: WebLogic Server * Application Monitoring: JRockit Mission ControlThe author has done a good job of presenting a complex subject in a coherent and easy-to-read manner. He has also provides many useful recipes which can be eventually incorporated into your application implementations. Overall, it provides a useful reference for all developers starting enterprise application development with Oracle ADF.

I found this book very useful to start working on ADF. I am an experienced middle/server side developer, with not much experience with front end development using Oracle Forms.This book helped me with ADF development being concise and very hands on in terms of development terminology using the associated tools. Yes a definite addition to ADF library.

With great pleasure I will try to convey my impressions about this book, as the author of it is Nick Haralabidis (which maintains the popular blogs JDeveloper FAQ and ADF Code Bits) with whom I collaborated on the successful and complex task of Oracle Forms 6i migration to ADF 11g project for Mednet International.Working on ADF for nearly a decade, is indeed striking that today there are countless sources of information, whether coming from official documentation, books or bloggers. The fundamental difference of JDeveloper Cookbook (which more accurately should have been called ADF Cookbook) is that it requires a thorough knowledge of the ADF and is not engaged in the interpretation or description of the main concepts; on the contrary it proposes solutions to real life development issues, that a structured team will encounter in a large scale project, demanding a solid and uniform treatment.The book deals with over 120 "recipes" for development in ADF 11g, covering the ADF BC, the ADF Controller, ADF Faces and various vertical issues as debugging, deployment, tuning, etc. The presentation style is outstanding and it follows the blogs of Nick: he first describes the problem and then a detailed, step by step solving approach follows with accompanying screenshots. After that a thorough explanation is given for the fine-grained details of the solution and in the end there are comments, ideas for extension and references. The advantages of this book therefore include the style of writing that is direct, comprehensive and complete. During the description of "recipes" there is plenty of source code, provided online, which I very much liked. On the other hand, there is an imbalance in the selection of recipes: some are offered already by the official documentation of Oracle (ie Fusion Middleware Developer's Guide), others are very simple to cite, others a bit more complex, while some important issues are missing IMHO such on transaction management, javascript support, ADF regions, etc. Let us examine in more detail the chapters of this book:The first chapter ("Prerequisites to Success: ADF Project Setup and Foundations") has to do with setting up the JDeveloper environment in Linux, the creation of base classes for a project, the libraries partitioning, the logging, creating page templates and the coverage of a custom generic actions framework. The library recipe, the page templates and the base classes are covered in great detail in the Oracle documentation and perhaps a simple reference of them would suffice. The second chapter ("Dealing with Basics: Entity Objects") contains recipes for generating keys out from Oracle Sequences, managing the life cycle of an entity (doDML, removal, child removal, validation) and although there are overlaps in the documentation is a very good chapter. The same applies to "A Different Point of View: View Object Techniques" which describes the iteration through the records of a view object, changing the updateable and queriable properties of an attribute programmatically, the maintenance of current row before and after a rollback, the detection of new records, the modification of the WHERE clause, etc. Perhaps it would be preferable to merge it conceptually with the next chapter ("Important Contributors: List of Values, Bind Variables, View Criteria ") which also covers some already known issues (cascade lovs, lov switcher, view criteria) but also adds new material such as changing or cleaning the bind variables or making case-insensitive queries.Moving to Chapter 5 ("Putting them all together: Application Modules") you will find recipes on how to create a Web Service from ADF BC and respectively of how to consume it as a Web Service client and a good example of activate / passivate framework behavior modification. Also there is coverage of statistics retrieval in terms of Application Modules, shared LOV modules and the extension of the Database Transaction Factory. Then, you will browse techniques for task flows initialization (with custom methods from the Application Module or from ADF task flow initializer), how to invoke a task flow URL, create a train flow or how to get information through the MDS. The chapter on ADF Faces introduces a few new elements as themes for customization of the af: query, usage the af: tree, the af: poll, the af: carousel, the af: selectManyShuttle or pop-up for row editing are found in the official documentation. But here stands out a recipe for page templates to reuse popups and also an indicative example for file export operation, despite the unfortunate realization of it (where the file contents are contained in a java.lang.String variable)"In Backing not Baking: Bean Recipes" chapter there are useful recipes for an af: popup to alert for pending changes, a custom row selection listener, an excellent reference for custom query listeners and for a popup to inform for long-duration transactions. There is also an example of using the af: iterator in a custom data collection and an unnecessary reference to session variables (which are discouraged by the framework) Chapter 9 ("Handling Security, Session Timeouts, Exceptions, and Errors") does not add something new on the security aspect (for example there is coverage of common knowledge about the ADF Security Wizard, the programmatic access to the security context, an example of a custom login page) In contrast, most intriguing recipes are those that describe the session timeout management and handling errors from a custom exception handler that transforms error messages coming from the ADF BC layer.The deployment chapter (Deploying ADF Applications) describes among others the use of ojdeploy tool to automate tasks (build and deploy) over Hudson CI. The next chapter (Refactoring, Debugging, Profiling, and Testing) I would say that describes mostly the theoretical capabilities of the platform rather than providing practical recipes for its usage. Topics covered here are the database synchronization of the ADF BC, the refactoring, the features of remote debugging and CPU profiling (which incidentally is not supported in Linux) Also how to manage log messages and the usage of JUnit for unit testing. There is compensation for this material in the last chapter (Optimizing,Fine-tuning, and Monitoring) where there are some good tips for optimizing the ADF BC (but relevant techniques for ADF Faces are lacking), there is an excellent recipe for Weblogic Work Managers and finally there is a poor report from the ADF standpoint about JRockit Mission Control to monitor a system.In conclusion I would say that this book excels at its writing style that should drive development teams to write their own cookbooks adapted to the peculiarities of their projects, borrowing many of the recipes found here. It is also a precious reference because it brings together best practices in a single title. It is definitely a must have for any ADF developer. On the other hand, it includes some matters that are largely detailed in official documentation of Oracle, and I would very much anticipate recipes about more sophisticated issues such as ADF regions, bindings, JSF 2.0, javascript integration, ui design and transaction management. Maybe an updated version or an online additional material could cover these in the future.

Nick Haralabidis has written "Oracle JDeveloper 11gR2 Cookbook" published by Packt. Firstly, as someone who has written a book himself, I should offer my congratulations to Nick. Writing a technical book like this is never easy and so those efforts should be recognised - so well done Nick and welcome to the ADF authors club. Now, onto the book review.As the name suggests, this is a mixed bag of, some common, some less common, development recipes for ADF development. So with that in mind the book isn't really about a structured learning path through ADF. What you have are examples that you can dip in and out of as you require. Of course, you are still learning and what I liked about this book was that you could learn something with a small well contained example. I would comment that if you are new to ADF then some of the recipes might scare you off a bit. For example, you are only at page 27 "Customizing exceptions", which sounds simple enough, but you end up with a whole page of code. Now, thats not an issue with the book per se, but keep in mind my point that this book is not aimed at structured learning starting at page 1 through to the end.What I did like, was the structure of each recipe. He has headings "Getting ready", "How to do it", "How it works" and "There's more". I really like this breaking down of the recipe and it makes it much easier to follow.That said, there were a few points I was hoping for a little more explanation and I did find a couple of places where I felt I would have done things differently and one or two places where I thought "Is that right??" (e.g. page 14 when the VC and Model project were bundled together, meaning if the JAR was added to a consuming Model project then it would contain VC artefacts). I also found (can't remember the pages number) when it seemed that EOs and VOs were getting mixed up in the description and the code. So the one or two little "oddities" made me a little nervous but so long as you keep your brain in gear and still question "is this right for my specific case", rather than following it blindly, then I think you'd be ok.To summarise, I think this book is a nice addition to the current ADF book library. I wouldn't recommend it if you were starting out learning ADF, but if you start coding/working on a real project then I think it wouldn't be a bad thing for the team to have this on their bookcase.

GREAT CONCEPTS DEPICTEDI like the information in this book. There are many concepts that are good to learn. An example is how to build an application modularly such that tasks could be assigned to members of a team for developing a large application.I also like the details regarding extending the basic application that is generated by the JDeveloper ADF wizards so that you have more micro management of the application's methods.GAPS, ASSUMPTIONS, AMBIGUITIES - NOT A TUTORIALWhat I have a problem with is the numerous gaps in documentation (maybe these are assumed to be understood by the user) - especially when compared to the source code that accompanies the book. Another way to state this is that many things are unclear. The best way to resolve the gaps and lack of clarity is to continually refer to the book's source code.Here are a couple of examples:p. 56 > the user is told how to test custom properties and a reference is made to the DepartmentAppModule application module. This does not even exist in the book's source code. The user is never instructed to even create this module. Yes, the user can make the necessary adjustment. However, my opinion is that this should have instructions somewhere in the book on how to accomplish this.p. 14, Steps 12 through 18 > This does not mention the important step of adding "SharedBC.jpr" to the Library Dependencies in the Deployment Profile Properties. You must do this for the configuration to be correct. This can be discovered by looking at the book's source code (as you will need to do continually).p. 16, Step 27 > "first select the appropriate project on the Application Navigator" - the reader is never told which project is the appropriate project.... you have to assume it is the SharedViewController project since that is the project the reader was working on at that moment.I am recommending this book to any ADF developer that wants to become a more effective technician. Just a word of warning: you will need to spend an extra amount of time to reconcile your application (if you are building one from the book) to the book's instructions. In the end, it will be worth it.