automating crosscutting modification
DESCRIPTION
Automating Crosscutting Modification. By Michael Kleyman. 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 Examples. Logging Authorization. Telecom Example. - PowerPoint PPT PresentationTRANSCRIPT
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