CSC/ECE 517 Fall 2010/ch3 3d mr

Aspect-oriented programming and AspectR

AspectR is a programming library that enables Aspect-oriented programming for Ruby programs by providing ways to wrap code around existing methods in a program. It is similar in functionality to the AspectJ library for Java, except simpler, less well known, and less documented. AspectR is distributed under the GNU General Public License.

Aspect-Oriented Programming

Aspect-Oriented Programming (AOP) is an approach to modularizing concerns that cut across the core concerns or business logic of a program. AOP is complimentary to Object Oriented Programming because it allows those concerns which cut across the program to be encapsulated into their own classes, called aspects.

Motivation

1. Take a shopping cart application with a Cart class and method add_to_cart():

class Cart
  has_many :items
  def add_to_cart(item)
    items << item
  end
end

This code is easy to understand and maintain.

2. Now add security, database transactions, and logging code:

class Cart
  has_many :items
  def add_to_cart(item)
    log('entering method')
    check_permissions
    conn = new_connection
    begin
      items << item
    rescue
      log('exception')
    ensure
      conn.close
    end
    log('leaving method')     
  end
end

3. Make the same changes to other business logic methods throughout the program.

4. Finally, try reusing this code in another application which has a different transaction framework, uses a different logging library, or handles security differently.

Aspect-Oriented Programming resolves this problem by encapsulating the concerns that cut across the program.

Terminology

AspectR uses a lot of the same terminology as AspectJ.

• Aspects - Classes that implement functionality needed in many parts of a program, but are not part of the business logic or core concern of the program.

• Advice - Borrowed from AspectJ terminology, refers to Aspect methods or code to be applied around existing business logic.

• Join Point - Places in the core business logic that advice should be applied or wrapped around.

The AspectR API

AspectR provides a simple mechanism for wrapping methods in a program. One begins by creating an "aspect" class that inherits from the AspectR Aspect class. For example, we define a new aspect class to implement a code profiler:

require aspectr.rb
include AspectR

class Profiler < Aspect
end

We then define the wrapper methods which will be called at the join points in the program. These methods are called Advice methods.

def method_start(method, object, exitstatus, *args)
  @begin = Time.now
end

def method_end(method, object, exitstatus, *args)
  timeElapsed = Time.now - @begin
  puts "#{object.class}.#{method} took #{timeElapsed} secs"
end

AspectR currently supports only two method join points, PRE and POST.

Given the simple example,

class SomeClass
  def some_method
    puts "hello"
    sleep 5
  end
end

One can add advice to be invoked before or after a single target method using the add_advice method, for example:

profiler = Profiler.new

profiler.add_advice(SomeClass, :PRE, :some_method, :method_start)
profiler.add_advice(SomeClass, :POST, :some_method, :method_end)

This advice can be removed using remove_advice:

profiler.remove_advice(SomeClass, :PRE, :some_method, :method_start)
profiler.remove_advice(SomeClass, :POST, :some_method, :method_end)

We can wrap both the before and after join points, and specify multiple target methods, for example the following code will wrap all the methods from the class SomeClass which match the regular expression "/some/" with our advice methods for the before and after join points:

profiler.wrap(SomeClass, :method_start, :method_end, /some/)

Similarly, this can be unwrapped:

profiler.unwrap(SomeClass, :method_start, :method_end, /some/)

Alternatively, you can have code directly injected into the beginning and ending of the target methods . This has performance advantages but cannot be unwrapped:

profiler.wrap_with_code(SomeClass, '@begin = Time.now', 'timeElapsed = Time.now - @begin; puts "took #{timeElapsed} secs"' , /some/)

To wrap methods from multiple target classes, the AspectR library defines a wrap_classes method. This is an experimental method and the API is likely to change [1]:

wrap_classes(profiler, :method_start, :method_end, /Some/, /some/)

One can specify that one or more methods which should never be wrapped by passing in the beginning of the method name to the constructor. There is also a wrappable? method to test if a method can be wrapped. For example this code will result in the wrap being ignored and return true:

profiler = Profiler.new("some")

profiler.wrap(SomeClass, :method_start, :method_end, /some/)

profiler.wrappable?(:some_method)

Code can be executed with dispatching by the API disabled using the disable_advice_dispatching instance method on the aspect class. Although temporary, the effect is global to the API. For example the following code will NOT result in the advice methods being called:

 profiler.wrap(SomeClass, :method_start, :method_end, /some/)

 profiler.disable_advice_dispatching { SomeClass.new.some_method }

One can test to see if the API dispatching is disabled using the Aspect class method dispatch?, for example:

Aspect.dispatch?

Examples

The following code examples implement a code profiler to measure the duration of method calls.

AspectR

require aspectr.rb
include AspectR

class Profiler < Aspect

  def method_start(method, object, exitstatus, *args)
    @begin = Time.now
  end

  def method_end(method, object, exitstatus, *args)
    timeElapsed = Time.now - @begin
    puts "#{object.class}.#{method} took #{timeElapsed} secs"
  end
end

The following code defines a class SomeClass and tests the aspect:

#if $0 == __FILE__
  class SomeClass
    def some_method
      puts "hello"
      sleep 5
    end
  end

  Profiler.new.wrap(SomeClass, :method_start, :method_end, /some/)
  SomeClass.new.some_method
#end

AspectJ

import java.util.Date;

aspect Profiler {
  private Date beginTime;
  
  pointcut myMethod(SomeClass s): target(s) && call(public * some*(..));

  before(SomeClass s): myMethod(s) {
    this.beginTime = new Date();
  }

  after(SomeClass s): myMethod(s) {
    Date newTime = new Date();
    int timeElapsed = this.beginTime.getTime() - newTime.getTime();
    System.out.println(thisJoinPointStaticPart + " took " + timeElapsed + " secs");
  }
}

Summary

Although the library is quite small, AspectR is a useful tool for implementing Aspect-Oriented Programming in Ruby programs. The main limitation of the library is that it only supports wrapping methods with join points either before or after the method calls. More complex join points are not supported at the time of this writing. Unlike AspectJ, however, AspectR conveniently does not require an intermediate step to generate the Java source code from the AspectJ code.

References

1. AspectR Ruby documentation (RDoc), AspectR module

External Links

• Aspect-Oriented Programming on Wikipedia
• AspectR home page
• AspectJ Programming Guide
• Programming Ruby - The Pragmatic Programmer's Guide
• GNU Public License
• [1]