CS 683 Emerging Technologies Spring Semester, 2003 AspectJ Syntax
	Previous    Lecture Notes Index    Next     © 2003, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 27-Jan-03

AspectJ Syntax

Possible Reasons to Use Aspects over Hand Coding
Aspect Terms
Pointcut Designators
When Advice can be Run
Pointcut Primitives

Call
Call & Execution

Accessing Fields with Primitive Pointcuts
withincode

Doc 3, AspectJ Syntax Slide # 2

AspectJ Syntax

public class Point
   {
   private double x;
   private double y;
   
   Point(double x, double y)
      {
      this.x = x;
      this.y = y;
      }
   
   public void setX(double x)
      {
      this.x = x;
      }
   
   public void setY(double y)
      {
      this.y = y;
      }
   
   public void setPolarCoordinates(double theta, double r)
      {
      x = r * Math.cos(theta);
      y = r * Math.sin(theta);
      }
   }

Doc 3, AspectJ Syntax Slide # 3

aspect PointChanged
   {
   private boolean Point.isDirty = false;
   
   public void Point.makeDirty()
      {
      isDirty = true;
      }
   
   public boolean Point.isDirty()
      {
      return isDirty;
      }
   
   public void Point.save()
      {
      isDirty = false;
      // add code to save point
      }
   
   pointcut fieldChanged(Point changed) : 
      call( * Point.set*(..)) && target(changed);
   
   after(Point changed ) : fieldChanged(changed)
      {
      changed.makeDirty();
      }
   }

Doc 3, AspectJ Syntax Slide # 4

import junit.framework.*;
public class PointTests extends TestCase
   {
   
   public static void main( String args[])
      {
      junit.swingui.TestRunner.run( PointTests.class);
      }
   
   public void testPointChange()
      {
      Point sample = new Point( 1, 1);
      assertFalse( sample.isDirty() );
      sample.setX(5);
      assertTrue( sample.isDirty());
      sample.save();
      assertFalse( sample.isDirty() );
      sample.setY(2);
      assertTrue( sample.isDirty());
      sample.save();
      assertFalse( sample.isDirty() );
      } 
   }
Doc 3, AspectJ Syntax Slide # 5

public class Point {
   private double x;
   private double y;
   private boolean isDirty = false;
   
   Point(double x, double y) {
      this.x = x;
      this.y = y;
   }
   
   public void setX(double x){
      this.x = x;
      isDirty = true;
   }
   
   public void setY(double y) {
      this.y = y;
      isDirty = true;
   }
   
   public void setPolarCoordinates(double theta, double r) {
      x = r * Math.cos(theta);
      y = r * Math.sin(theta);
      isDirty = true;
   }
   
   public boolean isDirty() {
      return isDirty;
   }
   
   public void save() {
      isDirty = false;
      // add code to save point
   }
}
Doc 3, AspectJ Syntax Slide # 6

Possible Reasons to Use Aspects over Hand Coding

• Point is an existing class and can’t or not allowed to change it

• Fewer bugs

As the number of methods in Point class increase, the more methods that will need to be modified to mark the object as dirty/clean. A programmer may miss some methods that change the state of the object. When programmers add new methods they may forget to add the code to mark the object dirty/clean. We also have to worry about subclasses. With aspects we only have to write one pointcut.

• Easier to change

If we change the type of events that are interested in aspects allows us to make the change in one location.

• Scales better with additional complexity

In some cases we may only be interested in when x changes, or when y changes or when both x & y change in one method. Keeping track of these as separate type of events in the Point class will get a bit tricky. Now imagine a class with 10 fields that can change in more complex ways that doubles. With aspects it will be easier to handle these complex situations.

• Flexibility

If we change our mind about the type of events we are interested in we change one aspect, rather than search all methods in the Point class and its subclasses

Doc 3, AspectJ Syntax Slide # 7

Aspect Terms

• Crosscutting Concern

Issues that cut cross many modules in a program

Issues dealt with in many modules in a program

• Join Point

A well-defined point in the program flow

Method call

Accessing a field

Initialization of an object

Handling an exception

• Pointcut designators (Pointcuts)

Selecting join points in a program

      pointcut fieldChanged(Point changed) : 
         call( * Point.set*(..)) && target(changed);

Doc 3, AspectJ Syntax Slide # 8

• Advice

Code that is run when a pointcut is reached

      after(Point changed ) : fieldChanged(changed)
         {
         changed.makeDirty();
         }

• Introduction

Modify the static structure of a class

Add fields and methods

Change the parent of a class

Add interfaces to a class

      private boolean Point.isDirty = false;

• Aspect

Unit of modularity for cross cutting concern

Contains pointcuts, advice, and introductions

Doc 3, AspectJ Syntax Slide # 9

Pointcut Designators

• call(MethodPat)
• call(ConstructorPat)
• execution(MethodPat)
• execution(ConstructorPat)
• initialization(ConstructorPat)
• staticinitialization(TypePat)
• get(FieldPat)
• set(FieldPat)
• handler(TypePat)
• within(TypePat)
• withincode(MethodPat)
• withincode(ConstructorPat)
• cflow(Pointcut)
• cflowbelow(Pointcut)
• if(Expression)
• this(TypePat | Var)
• target(TypePat | Var)
• args(TypePat | Var , ...)

Doc 3, AspectJ Syntax Slide # 10

• || (or)
• && (and)
• ! (not)

Doc 3, AspectJ Syntax Slide # 11

• *

Matches anything

Used in return type, Class name, method name

• (..)

Matches any argument list

execution(*  *(..))
call(* set(..)
execution(int *())
call(* setY(Double))
call(* Point.setY(int))

call(* Point.set*(int))
call( * Po*.set*(..))
call( * Po*.*et*(..))

Doc 3, AspectJ Syntax Slide # 12

When Advice can be Run

public class Hello
   {
   public static void main(String[] args )
      {
      System.out.println("Hello");
      }
   }

Doc 3, AspectJ Syntax Slide # 13

public aspect HelloAspect
   {
   before() : call(void main(String[]))
      {
      System.out.println( "Advice");
      }
   }

Doc 3, AspectJ Syntax Slide # 14

public aspect HelloAspect
   {
   after() : call(void main(String[]))
      {
      System.out.println( "Advice");
      }
   }

Doc 3, AspectJ Syntax Slide # 15

public aspect HelloAspect
   {
   void around() : call(void main(String[]))
      {
      System.out.println( "Advice");
      }
   }

Doc 3, AspectJ Syntax Slide # 16

Doc 3, AspectJ Syntax Slide # 17

Pointcut Primitives

Call

• call(MethodPat)
• call(ConstructorPat)

Doc 3, AspectJ Syntax Slide # 18

Call & Execution

When a method is called

When the body of code for an actual method is executes

Doc 3, AspectJ Syntax Slide # 19

public class Hello {
   public static void main(String[] args ){
      System.out.println("Hello");
   }
}

public aspect HelloAspect {
   before() : call(void main(String[])) {
      System.out.println( "call-before");
   }
   
   after() : call(void main(String[])) {
      System.out.println( "call-after");
   }
   
   before() : execution(void main(String[])) {
      System.out.println( "execution-before");
   }
   
   after() : execution(void main(String[])) {
      System.out.println( "execution-after");
   }
}

Doc 3, AspectJ Syntax Slide # 20

public class Hello {
   public Hello() {
      this(5);
      System.out.println("Hello()");   
   }
   
   public Hello(int x) {
      System.out.println("Hello(" + x + ")");
   }
   
   public static void main(String[] args ) {
      new Hello();
   }
}

public aspect HelloAspect {
   before() : call( Hello.new(..) ) {
      System.out.println( "call-before");
   }
   
   before() : execution(Hello.new(..)) {
      System.out.println( "execution-before");
   }
}

Doc 3, AspectJ Syntax Slide # 21

public class Hello {
   public void foo() {
      System.out.println( "Hello.foo");
   }   
   public static void main(String[] args ) {
      Hello test = new HelloChild();
      test.foo();
   }
 }

public class HelloChild extends Hello {
   public void foo() {
      super.foo();
      System.out.println( "HelloChild.foo");
   }
}

public aspect HelloAspect {
   before() : call( * foo(..) ) {
      System.out.println( "call-before");
   }
   
   before() : execution(* foo(..)) {
      System.out.println( "execution-before");
   }
}

Doc 3, AspectJ Syntax Slide # 22

import java.lang.reflect.*;
   
public class Hello {
   public void foo() {
      System.out.println( "Hello.foo");
   }   
   
   public static void main(String[] args ) throws Exception {
      Class helloClass = Hello.class;
      Class[] argumentTypes = { };
       Method foo = helloClass.getMethod( "foo", argumentTypes ); 
       Object[] arguments = { };
      Hello test = new Hello();
       foo.invoke( test, arguments ); 
   }
}

public aspect HelloAspect {
   before() : call( * foo(..) ) {
      System.out.println( "call-before");
   }
   
   before() : execution(* foo(..)) {
      System.out.println( "execution-before");
   }
}

Doc 3, AspectJ Syntax Slide # 23

Accessing Fields with Primitive Pointcuts

get( int Point.x)

Refers to any time int Point.x is read

set( !private * Point.*)

Refers to any time a non-private field of Point is set

Doc 3, AspectJ Syntax Slide # 24

withincode

Refers to any join point in side the given method or constructor

pointcut fieldChanged(Point changed) : set( private double Point.*)
          && target(changed) && withincode(*  Point.*(..));

pointcut fieldChanged(Point changed) : set( private double Point.*) 
         && target(changed) && !withincode( Point.new(..));

pointcut fieldChanged(Point changed) : set( private double Point.*) 
         && target(changed) && withincode(*  *.*(..));

Doc 3, AspectJ Syntax Slide # 25

aspect PointChanged {
   private boolean Point.isDirty = false;
   
   public void Point.makeDirty() {
      isDirty = true;
   }
   public boolean Point.isDirty() {
      return isDirty;
   }
   
   public void Point.save() {
      isDirty = false;
      // add code to save point
   }
   
   pointcut fieldChanged(Point changed) : set( private double Point.*) 
         && target(changed) && !withincode( Point.new(..));
   
   after(Point changed ) : fieldChanged(changed) {
      System.out.println("Make Dirty");
      changed.makeDirty();
   }
}

Doc 3, AspectJ Syntax Slide # 26

import junit.framework.*;
public class PointTests extends TestCase
   {
   public static void main( String args[])
      {
      junit.swingui.TestRunner.run( PointTests.class);
      }
   public void testPointChange()
      {
      Point sample = new Point( 1, 1);
      assertFalse( sample.isDirty() );
      sample.setX(5);
      assertTrue( sample.isDirty());
      sample.save();
      assertFalse( sample.isDirty() );
      sample.setY(2);
      assertTrue( sample.isDirty());
      sample.save();
      assertFalse( sample.isDirty() );
      } 
   }
Doc 3, AspectJ Syntax Slide # 27

pointcut fieldChanged(Point changed) : set( private * Point.*) 
   && target(changed) && withincode(*  *.*(..));

pointcut fieldChanged(Point changed) : set( * double Point.*) 
   && target(changed) && withincode(*  *.*(..));

Previous    visitors since 27-Jan-03    Next