Aspect%20Oriented%20Programming

1
Aspect Oriented Programming

• Michael Kucera
• CAS 706
• March 15, 2005

2
Motivation for AOP

• Typical programs often have behavior that doesn't
  fit into a single module.
• Code Tangling

Accounting
XML Parsing
Logging
Database
3
Crosscutting Concerns

• AOP addresses behaviors that span many, often
  unrelated, modules.
• Core Concerns
• Primary core functionality.
• Central functionality of a module.
• Crosscutting Concerns
• System wide concerns that span multiple modules.
• Cuts across the typical division of
  responsibility.
• OOP creates a coupling between core and
  crosscutting concerns.
• AOP aims to modularize crosscutting concerns.

4
Aspects

• In AOP crosscutting concerns are implemented in
  aspects instead of fusing them into core modules.
• Aspects are an additional unit of modularity.
• Aspects can be reused.
• By reducing code tangling it makes it easier to
  understand what the core functionality of a
  module is.
• An aspect weaver takes the aspects and the core
  modules and composes the final system.

5
AspectJ Example

• public class Example
• public static void deliverMessage(String
  message)
• System.out.println("The message is "
  message)
• public static void main(String args)
• deliverMessage("I'm here")
• deliverMessage("AspectJ rocks")
• public aspect ExampleAspect
• pointcut helloPC() call(void
  Example.deliverMessage(..))
• before() helloPC()
• System.out.print("Hello! ")

Output Hello! The message is I'm here The
message has been delivered. Hello! The message
is AspectJ rocks The message has been delivered.
6
Weaving

• Weaving rules specify how to integrate the final
  system.
• Can be implemented in various ways
• Source to source translation.
• Bytecode enhancement, first compile source with
  original compiler, then weave aspects into class
  files.
• Just-in-time weaving done by a classloader.
• By the language compiler.
• The JAsCo language supports runtime weaving and
  unweaving.

7
AspectJ Overview

• Join point
• Places where crosscutting concerns can be woven
  in.
• Ex. method call, field access, object creation.
• Pointcut
• Declaration that selects join points and collects
  contexts at that point.
• Advice
• Code to be executed at a join point.
• Three types before, after and around.
• Aspect
• Unit of modularity.
• Can contain fields and methods like a regular
  Java class.

8
AspectJ Overview

• Introduction
• Introduces changes to classes.
• Makes static changes that alone do not effect be
  behavior of the system.
• Can add methods and fields to a class.
• Add implemented interfaces.
• Adds mixin like inheritance to Java.
• Compile time declaration
• Add compile time errors and warnings upon
  detecting certain usage patterns.
• Every valid Java program is a valid AspectJ
  program.

9
AspectJ Join point model

• Any identifiable execution point

• method body
• method call
• constructor body
• constructor call
• field access

• catch block
• class (static) initialization
• object initialization
• object pre-initialization
• advice execution

• All join points have a context. Certain pointcuts
  can capture the context and pass it to the advice.

10
AspectJ Capturing Context
public class Employee int salary public
void setSalary(int salary) this.salary
salary public static void main(String
args) Employee emp new Employee() emp.set
Salary(50000) System.out.println("Salary "
emp.salary) public aspect MoneyAspect
pointcut employeePC(int salary) call(
Employee.setSalary(..)) args(salary) void
around(int salary) employeePC(salary)
salary 2 proceed(salary)
Output Salary 100000
11
What about encapsulation?

• AOP breaks encapsulation in a controlled manner.
• Encapsulation is broken between classes and
  aspects.
• Aspects marked as privileged have access to the
  private members of a class.
• Encapsulation is preserved between classes.
• An aspect encapsulates a crosscutting concern.

12
AspectJ - Pointcuts

• Can be named or anonymous.
• Named pointcuts
• access-specifier pointcut pointcut-name(
  args ) pointcut-definition
• The pointcut-definition part consists of
  anonymous pointcuts.
• Anonymous pointcut used in advice definition
• before() call( Account.(..))
• ... advice body

13
AspectJ - Pointcuts

• Pointcuts can use combinations of other pointcuts.

pointcut employeeCalls() call(
Employee.(..)) pointcut internalOperations()
employeeCalls()
within(banking..)

• Wildcards can be used to capture join points that
  share common characteristics.
• denotes any number of characters except a
  period
• .. denotes any number of characters
• denotes any subclass of a given type
• Can use operators , and ! within a pointcut
  definition.

14
AspectJ Kinded pointcuts

• Kinded pointcuts capture exposed join points.

Join point category
Pointcut syntax
Method execution execution(MethodSignature)
Method call call(MethodSignature)
Constructor execution execution(ConstructorSignature)
Constructor call call(ConstructorSignature)
Class initialization staticinitialization(TypeSignature)
Field read access get(FieldSignature)
Field write access set(FieldSignature)
Exception handler execution handler(TypeSignature)
Object initialization initialization(ConstructorSignature)
Object pre-initialization preinitialization(ConstructorSignature)
Advice execution adviceexecution()
15
AspectJ Control-flow based pointcuts

• Capture all the join points within the control
  flow of a join point.
• cflow(call( Account.debit(..)))
• All the join points within the control flow of
  any debit method in the Account class, including
  the call to debit().
• cflowbelow(call( Account.debit(..)))
• Same as above but not including the call to
  debit().
• cflowbelow can be used to select non-recursive
  calls.

16
AspectJ Pointcuts that capture context

• this()
• the current object
• target()
• target object of a method call
• args()
• arguments passed to a method or constructor
• exception caught by a handler join point
• new value to be set in a field write access
• this.obj.doSomething(val)

args()
this()
target()
17
AspectJ Advice

• Advice is a method like construct that expresses
  the action to be taken at the join points that
  are captured by a pointcut.
• Before advice
• executes prior to the join point
• After advice
• executes following the join point
• Around advice
• surrounds the join points execution
• can continue original execution, bypass execution
  or cause execution with an altered context
• can cause execution of the join point multiple
  times

18
AspectJ Around advice
public aspect AccountAspect void
around(Account account, float amount) call(
Account.withdraw(float)) target(account)
args(amount) System.out.println("Befor
e withdrawl of amount " amount) if(amount
gt account.getBalance()) System.out.println("Can
not make withdrawl") else proceed(account,
amount) System.out.println("Withdrawl
successful, balance "
account.getBalance())
19
AspectJ After advice

• Executes after the execution of a join point.
• Can distinguish between normal returns and those
  that throw an exception.

after() returning call( Account.(..))
System.out.println(Successful
return) after() throwing call(
Account.(..)) System.out.println(Failure)
after() throwing(RemoteException ex) call(
.(..)) System.out.println(Exception ex
while executing
thisJoinPoint)
20
AspectJ Method result caching
public class Factorial public static long
factorial(int n) if(n 0) return
1 return n factorial(n - 1) public
static void main(String args)
System.out.println("Result "
factorial(5)) System.out.println("Result "
factorial(5)) public aspect
FactorialOptimizeAspect private Map cache
new HashMap() pointcut factorialOp(int n)
call(long .factorial(int)) args(n) long
around(int n) factorialOp(n) Object value
cache.get(new Integer(n)) if(value null)
return proceed(n) System.out.
println(value " retrieved from
cache") return ((Long)value).longValue()
after(int n) returning(long result)
factorialOp(n) if(cache.put(new Integer(n),
new Long(result)) null)
System.out.println(result " added to
cache")
Output 1 added to cache 1 added to cache 2 added
to cache 6 added to cache 24 added to cache 120
added to cache Result 120 120 retrieved from
cache Result 120
21
AspectJ Aspects

• Aspects can
• Include data members and methods.
• Be declared abstract (wont be weaved).
• Have access specifiers.
• Extend classes or aspects.
• Implement interfaces.
• Aspects are not the same as classes
• Cannot be directly instantiated.
• Cannot inherit from concrete aspects.
• Can be marked as privileged.

22
AspectJ Abstract aspect example
public abstract aspect AbstractLogging
public pointcut logPoints() call(
.(..)) public abstract Logger
getLogger() before() logPoints()
getLogger().log(Level.INFO,
thisJoinPoint.toString()) public aspect
FactorialLoggingAspect extends AbstractLogging
// pointcut override public pointcut
logPoints() call( .factorial(..)) public
Logger getLogger() return Logger.global
23
Static crosscutting

• Dynamic crosscutting modifies the execution
  behavior of the program.
• Static crosscutting modifies the structure of the
  program.
• Member introduction.
• Type-hierarchy modification.
• Compile-time warning declaration.
• Exception softening.
• Member introduction adds data members and methods
  to classes.

24
Introduction Mixin style inheritance
public interface Tagable void setTag(String
tag) String getTag() public aspect
TagAspect private String Tagable.tag public
String Tagable.getTag() return
tag public void Tagable.setTag(String tag)
this.tag tag declare parents
Employee implements Tagable before(Tagable t)
target(t) !within(TagAspect)
t.setTag(thisJoinPoint.toString()) afte
r(Tagable t) target(t) !within(TagAspect)
System.out.println(t.getTag())
25
Default interface implementation
public interface Tagable public void
setTag(String tag) public String
getTag() static aspect Implementation
private String Tagable.tag public void
Tagable.setName(String tag) this.tag
tag public String Tagable.getName()
return tag public class Example
implements Tagable public static void
main(String args) Example ex new
Example() ex.setTag(It works) System.out.p
rintln(Tag ex.getTag())
26
Modifying the class hierarchy

• Existing classes can be declared to implement an
  interface or extend a superclass.
• Works as long as Java inheritance rules are not
  violated (no multiple inheritance).
• declare parents Type implements
  InterfaceList
• declare parents Type extends Class
• Aspects can be made dependant only on a base type
  or interface. This makes aspects more reusable.

27
AspectJ Exception softening

• Converts a checked exception into a runtime
  exception.
• Sometimes it can be inconvenient to have to deal
  with checked exceptions. Involves a proliferation
  of try/catch blocks and throws clauses. Example
  SQLException in JDBC API
• declare soft SQLException within(DatabaseAcce
  ss)
• Exception is automatically rethrown as a
  org.aspectj.lang.SoftException

28
Policy Enforcement

• Mechanism for ensuring that system components
  follow certain programming practices.
• For example enforce that public access to
  instance variables is prohibited.
• Avoid incorrect usages of an API.
• Ensures better quality.
• In AOP policy enforcement concerns can be
  implemented in aspects.
• Aspect based policy enforcement is reusable.
• AOP can be used for Design by Contract.

29
Policy Enforcement in AspectJ

• Compile time and runtime enforcement.
• In AspectJ it is possible to specify custom
  compile time warnings and errors using pointcuts.
• declare warning get( System.out) get(
  System.err)
• consider using Logger.log() instead
• declare error set(public ) get(public
  )
• nonpublic access is not allowed
• Runtime enforcement can be achieved through
  advice that detects policy violations.

30
Aspect precedence

• It is possible for more than one piece of advice
  to apply to a join point.
• It may be important to control the order in which
  advice is applied.
• declare precedence Aspect1, Aspect2, ...
• In the absence of any specified precedence
  control, the order in which the advice is applied
  is non-deterministic (at compile time).
• If more than one piece of advice in the same
  aspect applies to a pointcut, then the advice
  that comes first in the file has precedence.

31
Aspect association

• Typically an aspect represents a singleton object
  (aspect instance) that is instantiated by the
  system.
• It may be useful to have more than one instance
  of an aspect in the system. Can create
  associations between aspect instances and other
  objects.
• Can associate a new aspect instance with a target
  object by using a pointcut.
• public aspect CacheAspect perthis(access()) ..
  
• Alternatively can use introduction.

32
CLOS Method combination

• Applicable generic methods are combined into a
  single effective method.

(defclass food () ()) (defclass pie (food)
()) (defmethod cook ((p pie)) (print "Cooking
a pie.")) (defmethod cook before ((f food))
(print "A food is about to be cooked.")) (defmeth
od cook after ((f food)) (print "A food has
been cooked.")) (defmethod cook before ((p
pie)) (print "A pie is about to be
cooked.")) (defmethod cook after ((p pie))
(print "A pie has been cooked.")) (setq pie-1
(make-instance 'pie)) (cook pie-1)
Output A pie is about to be cooked A food is
about to be cooked Cooking a pie A food has been
cooked A pie has been cooked
33
JAsCo An aspect oriented language

• Emphasizes aspect reuse.
• In AspectJ pointcuts are hardcoded... less reuse.
• JAsCo allows adding, altering and removing
  aspects while the program is running.
• Supports runtime weaving and unweaving.
• Aspect beans
• Contain hooks abstract pointcut definitions
  together with advice
• Connectors
• used to deploy reusable aspect beans
• explicitly specify the way aspect beans are
  combined

34
JAsCo Stateful aspects
class LoggerBean hook LogHook
LogHook(startmethod(..args1), runningmethod(..args
2), stopmethod(..args3)) start gt
pc1 pc1 execution(startmethod) gt pc3
pc2 pc3 execution(stopmethod) gt
pc1 pc2 execution(runningmethod) gt
pc3 pc2 before pc2 ()
System.out.println(executing
calledmethod.getName())
static connector testconnector
LoggerBean.LogHook hook1 new
LoggerBean.LogHook( ..start(), .doIt(),
..stop()) LoggerBean.LogHook hook2
new LoggerBean.LogHook( ..login(),
.shop(), ..logout()) hook1.before()
// optional hook2.before()
35
Case study JDO

• JDO (Java Data Objects) is a transparent
  persistence framework for Java.
• Allows the manipulation of the state of an object
  to transparently update a database.

Employee
public class Employee string name int
salary
Name Salary
Fred 100 200
Biff 150
fred.salary 200
causes transparent update
36
Case study JDO

• Uses advice to add side effects to field access.
• Weaving is done by the JDO bytecode enhancer.

javac
Employee.java
Employee.class
JDO bytecode enhancer (Aspect weaver)
mapping.xml
enhanced Employee.class
37
Conclusion

• AOP has many potential benefits.
• Higher modularization.
• Cleaner responsibilities for individual modules.
• Improved separation of concerns.
• Easier system evolution. Much easier to add
  crosscutting functionality.
• More code reuse.
• Can make code easier or harder to understand.
• Already starting to become mainstream (JBoss,
  JDO, Spring).
• Like any new technology, AOP can be abused.

38
References

• Laddad, Ramnivas. AspectJ in Action. Greenwich,
  Conn. Manning Publications, 2003.
• Lesiecki, Nicholas. Improve modularity with
  aspect oriented programming. IBM Developerworks,
  January,2002. Available online at
  http//www-106.ibm.com/developerworks/java/library
  /j-aspectj.
• Marshall, Joe. Warp Speed Introduction to CLOS.
  Available online at http//home.comcast.net/prune
  squallor/guide.html.
• Vanderperren, W., Suvee, D., Cibran, M. and De
  Fraine, B. Stateful Aspects in JAsCo. In
  proceedings of SC 2005, LNCS, April 2005
• Eclipse AspectJ plug-in, http//eclipse.org/aspect
  j.