crystal reports barcode AOP Tools Comparison in Font

Encoder Data Matrix 2d barcode in Font AOP Tools Comparison

he previous chapters presented four of the most widely used tools for AOP: AspectJ, JAC, JBoss AOP, and Spring AOP. This chapter compares these four tools with regard to programming aspect-oriented applications. AspectJ, JAC, JBoss AOP, and Spring AOP each has its own techniques for implementing the concepts of AOP presented in 2. The three main concepts of AOP aspect, pointcut, and advice can be implemented with each of the four tools, but their forms as well as the means for programming them, such as syntax and API, vary. The terms used to describe these concepts may also vary among the tools; for example, the term advice is used by AspectJ, whereas JAC uses the term wrapper and JBoss AOP uses interceptor. Besides some minor conceptual and terminology differences, these tools can be classified into two types of approaches: the language approach (AspectJ) and the framework approach (JAC, JBoss, and Spring). These two types of approaches imply some important differences, which we ll cover in this chapter. Table 7-1 sums up and compares the features of AspectJ, JAC, JBoss AOP, and Spring AOP, which we ll cover in more detail throughout this chapter.

Weaver Compile time or Run time implementation load time Aspect Pointcut Keyword aspect Class extending AspectComponent

Dedicated syntax Method pointcut XML tags with XML with Perl 5 regular with GNU regular java.util.regexp expressions expression expressions Advice code proceed Wrapper proceed Interceptor invokeNext Interceptor proceed

Declaration order org.springframework. in the core.Ordered interface jboss-aop.xml file implementation

The heart of an aspect-oriented system is the aspect weaver. It is a tool used for integrating aspects with classes. Several ways of performing the weaving exist. AspectJ employs a compiletime weaver, which is typical of the language approach, whereas JAC, JBoss AOP, and Spring AOP use run-time weavers, which are typical of the framework approach. The AspectJ weaver can take either source code or bytecode as input. In addition to the compile-time weaving mode is a load-time mode, where aspects can be woven while the bytecode of the application is loaded into the JVM. The advantage of compile-time (or load-time) weaving is that it delivers woven applications with better execution times than are possible for run-time weaving. The disadvantage is that there is no distinction in the executed code between the aspect code and the application code. If the programmer needs to modify, add, or remove an aspect, then the entire application must be woven again. With JAC, JBoss AOP, and Spring AOP, classes and aspects are compiled separately, and the weaving is performed while the application is loaded and executed. Aspect and class instances are separate run-time entities, and the weaver orchestrates the execution according to the weaving directives. In such a mode, the weaving is an operation very similar to binding: an aspect instance is bound to the objects where the aspect applies. The advantage of this mode is that the binding can be dynamically modified, thus enabling the removal of aspects and the weaving of new aspects without recompiling the application. This feature can be useful for applications such as web servers, which have to be readily available, since new features can be deployed without stopping the application. One of the disadvantages of run-time weaving is that the applications are generally slower than statically woven ones. Note that although AspectJ could also implement run-time weaving, it is less natural as AspectJ follows the language approach. Most of the type checking performed by the compiler would then be disabled, which would erase most of the advantages of the language approach. On the other hand, the framework approach can hardly implement compile-time weaving, since it would imply some preprocessing tool, which is implemented much more efficiently by the language approach.