Foundations of AOP for J2EE Development (Foundation)

Foundations of AOP for J2EE Development covers a relatively new programming paradigm: aspect-oriented programming, or AOP. Presented are the core concepts of AOP: AspectJ 5, JBoss AOP, Spring AOP, and JAC. Specific features of these tools are compared. The book also explores the potential uses of AOP in everyday programming life, such as design patterns implementation, program testing, and application management.

In the latter part of the book, the authors show how AOP can ease the task of J2EE application development. (J2EE is known for being a rich and somewhat complicated framework.)

User review
OK book
What I like about this book is the academic texture to the way they cover the concept. These days it is very hard to find a decent book that would cover a technical concept in a unambiguous (well-defined) way, since most of the authors try to be as casual as they can (either intentionally or not). This is one of few books that has some level of guaranteed correctness/thoroughness to it. Having said that, they are trying to cover too much in a short time.

User review
Good book
Foundations of AOP is an introductory book about the new programming paradigm `Aspect Oriented Programming` that takes care of crosscutting functionalities and code scattering to help you create better structured and clearer programs.

The book starts defining the new concepts related to AOP (joinpoints, poincuts, aspects, etc) using some examples in pseudo code and then describes 4 of the most popular tools that exist today: AspectJ, JAC (Java Aspect Components), JBoss AOP and Spring AOP. These descriptions are very complete, showing complete syntax, configuration and compilation instructions for each case. Basically, it implements the same example with the different tools so you can compare them.

There is a chapter dedicated only to compare the 4 tools mentioned above. This comparison includes the weaver implementation, syntax for pointcut definition, aspects, jointpoint types, jointpoint instrospection, introduction mechanism, advice code type and some advanced features like aspect instantiation, ordering and reuse.

The book also covers some design patterns using AOP. It shows implementation of well known patterns like singleton, observer, command, etc, using some of the tools described before and then evaluates these implementations to see if they are optimal for real world solutions.

Another topic covered is quality of service and AOP. Here the authors show us how to use AOP to verify that an application's definition and execution correspond to its identified requirements. They achieve this by implementing what is called design by contract using AOP. They also show two testing techniques (coverage analysis and nonregression test), and the use of AOP to integrate JMX with a java application.

The last three chapters are dedicated to show the full potential of AOP in a sample J2EE application. It shows how to use AOP in the business, presentation and client tiers.

Finally, I could say the book is very good introducing the concepts of AOP and describing several tools that implement them. If you have none o little knowledge of AOP, this could give you a good start. Even if you already know some of the tools described here, this book can be used as a reference. The only thing to consider is that the book doesn't cover the latest releases of some of the tools.