Aspect weaver

Motivation

Many programming languages are already widely accepted and understood. However, there is no significant desire to create radically different programming languages to support the aspect-oriented programming paradigm due to business-related risks associated with adopting new technologies.^[1] Use of an entirely new language relies on a business's ability to acquire new developers. Additionally, the existing code base of a business would need to be discarded. Finally, a business would need to acquire a new toolchain (suite of tools) for development, which is often expensive in both money and time.^[2] Primary concerns about roadmaps for the adoption of new technologies include the need to train new developers and adapt existing processes to the new technology.^[3]

To address these business concerns, an aspect weaver enables the use of widely adopted languages like

Through this weaving process, aspect weavers allow for code which otherwise would have been duplicated across classes. By eliminating this duplication, aspect weavers promote modularity of cross-cutting concerns.^[8] Aspects define the implementation code which otherwise would have been duplicated and then use pointcuts and join points to define the advice. During weaving, the aspect weaver uses the pointcuts and join points, known as a pointcut designator, to identify the positions in candidate classes at which the implementation should be injected.^[9] The implementation is then injected into the classes at the points identified, thus permitting the code to be executed at the appropriate times without relying on manual duplication by the programmer.^[10]

aspect Logger {
    pointcut method() : execution(* *(..));
    before() : method() {
        System.out.println("Entering " + 
            thisJoinPoint.getSignature().toString());
    }
    after() : method() { 
        System.out.println("Leaving " + 
            thisJoinPoint.getSignature().toString());
    }
}
public class Foo {
    public void bar() {
        System.out.println("Executing Foo.bar()");
    }
    public void baz() {
        System.out.println("Executing Foo.baz()");
    }
}

public class Foo {
    public void bar() {
        System.out.println("Entering Foo.bar()");
        System.out.println("Executing Foo.bar()");
        System.out.println("Leaving Foo.bar()");
    }
    public void baz() {
        System.out.println("Entering Foo.baz()");
        System.out.println("Executing Foo.baz()");
        System.out.println("Leaving Foo.baz()");
    }
}

Weaving in AspectJ

In the

The aspect weaver analyzes the advice specified by the pointcut in the aspect and uses that advice to distribute the implementation code into the defined class. The code differs slightly in each method due to slight variances in requirements for the method (as the method identifier has changed). The aspect weaver determines the appropriate code to generate in each situation as defined by the implementation advice and then injects it into methods matching the specified pointcut.^[13]

Weaving to bytecode

Instead of generating a set of woven

• Aspect-oriented programming
• Preprocessor
• Compiler

References

Bibliography