Automating Crosscutting Automating Crosscutting ModificationModification

By Michael Kleyman

When AOP is Used?When AOP is Used?

It is usually said that aspects represent crosscutting concerns.

No clear definition of such a concern.AOP can be dangerous when overused.

Trivial ExamplesTrivial Examples

LoggingAuthorization

Telecom ExampleTelecom Example

Calls, messaging etc. are the core conceptsRepresented by classes, such as Call or Connection

Billing is the crosscutting concern, represented by an aspect.

Payment calculation initiated in advices to methods of the core classes.

When AOP is helpful, but not When AOP is helpful, but not usedused

Corporate policies do not allow use of experimental, immature technologies

An aspect allows rapid modification of existing code, but the resulting program structure is not the best possible structure

Crosscutting modification as opposed to crosscutting concern

Example: Object PoolingExample: Object Pooling

Goal: reuse objects instead of creating new ones

Can be represented by a factory class.Introducing object pooling into existing

system is difficult.AspectJ allows an easy but controversial

solution

What is ACMEWhat is ACME

Convert AspectJ solution to pure JavaProve of conceptBased on specific examplesAdditional examples may be covered later

Key GoalsKey Goals

Java code must produce exactly the same results as the aspect code.

Java code should not be significantly longer than the aspect code.

The produced code should be easily modified and used.

Key Goals (Continued)Key Goals (Continued)

The generated code must look similar to code written by a human programmer.

Based on commonly used patterns and idioms.

ACME vs. AspectJ CompilerACME vs. AspectJ Compiler

Must not support the entire languageMust generate meaningful names (possibly

with user’s help)May not use some complicated structures

used in the compiler.

Workflow with ACMEWorkflow with ACME

Implement the required modification using aspects

Test the implementationWhen the result is satisfactory, run ACME

to generate pure Java code with same functionality

Creating Singleton ClassCreating Singleton Class

Aspect interacts with other code through pointcuts on functions of a single class.

Aspect is converted to a class automatically.All calls that are advised by the aspect are

replaced by calls to the singleton.Example: object pooling.

Inlining Aspect CodeInlining Aspect Code

Aspect may be used to modify both interface and behavior of an existing class.

Involves both advises and inter-type member declarations.

Example: modification of the Point class.Example: introduction of transactions

Automatic ModificationAutomatic Modification

Add the member introduced by the inter-type declaration to the class

Add a function for each adviceReplace all calls advised by the aspect by

calls to the new functions

Aspect HierarchiesAspect Hierarchies

Allow code reuse in several aspectsTypically involve abstract pointcuts and

concrete implementation of the advicesTransformed into hierarchies of classes

where the leaves are implemented as singletons.

When ACME helps?When ACME helps?

Evolution aid: test before changing the system.

RefactoringEases adoption of aspect technology

When not?When not?

Aspect represent crosscutting concernsAspects used as a configuration tool for

different application of the system

Unsupported Language Unsupported Language FeaturesFeatures

WildcardsType-dependent pointcut definitionsImplicit type castingCompile-time applications of aspects, such

as “declare error”Execution pointcuts

More on More on executionexecution join points join points

Require replacing the implementation of functions, not the calls to them.

With inheritance require replacing several functions for each advice.

Anything but the simplest around advice must be transformed to very complicated code

Very limited benefit

Case StudyCase Study

ACME was applied to Shay Raz’s work on system scaling with aspects.

Some aspects required cosmetic changes before processing.

Some can not be processed because they involve implicit type casting.

Possible solution: rewrite the aspects, removing abstract pointcuts from the base aspect.

Implementation DetailsImplementation Details

Built as an Eclipse pluginUses JDT library for Java source

manipulationThere is no such library for AspectJ code

Algorithm StepsAlgorithm Steps

Parse the AspectJ filesCreate new classes for “singleton” aspects.Add new members to existing classesFind advised function calls (using JDT)Replace these calls by calls to generated

functions