Aspect-oriented programming examples

Question

Can anyone post an example of Aspect-oriented programming (AOP) that is not logging?

I've looked at several resources but all the examples are trivial logging. What is it useful for?

Answer 1

One of the examples which was loaned straight from this Aspect Oriented Programming: Radical Research in Modularity, Youtube video was painting to a display. In the example you have a drawing program, which consists of points, shapes, etc and when changes to those objects occur you need to tell the display to update itself. Without handling it in an aspect you end up repeating yourself quite a bit.

AOP, as I've understood it, was created for not repeating yourself for cross cutting concerns which might not have anything to do with business logic. With aspects you can modularize these concerns to aspects. One of the examples was logging but there are bunch of different things you might end up repeating. It has been evolving since and it's not any more about aspect-oriented programming but there's also aspect-oriented modelling.

More information about aspect oriented programming can be found from these sources:

• to read:
  • Wikipedia - Aspect-oriented programming
• to listen:
  • Software engineering radio - Episode 106: Introduction to AOP
  • Software engineering radio - Episode 11: Interview Gregor Kiczales
• to watch:
  • Google Video - Anurag Mendhekar: Aspect-Oriented Programming (Dan Friedman's 60th Birthday)
  • Youtube - Aspect Oriented Programming: Radical Research in Modularity
  • Youtube - Aspect-Oriented Modeling - what it is and what it's good for

Answer 2

Security

• Inject code that checks permissions and blocks access

Friendlier error msgs for asp.net webcontrols/webparts

• Inject code that catches exceptions and writes stacktrace when debug-compiled or friendly messages when error-compiled (like the stuff here: Transparent generic exception handling for asp.net / MOSS2007 (with code) )

Performance

• Inject code that sets perf counters to get an overview of where your app is slow

Answer 3

Validation:

[NotNull]
public string Property1 { get; set; }

[Length(Min = 10, Max = 20)]
public string Property2 { get; set; }

[Regex(Expression = @"[abc]{2}")]
public string Property3 { get; set; }

Answer 4

Undo - I am calling a third-party assembly that supports undo operations. It requires callers to create an undo context, call some methods in the assembly, adn then destroy the undo context. Contexts can be nested. Also, if a context is created but left in an undesirable state that requires an app restart.

Normally to use undo I would write something like this

    void foo()
    {
        int id = lib.create_undo_context();
        try
        {
            lib.performsomeaction();
            lib.performsomeaction();
            lib.performsomeaction();

        }
        finally
        {
            lib.destroy_undo_context(id);
        }
    }

with PostSharp I define an attribute called [Undo] that creates the undo context when the method starts and destroys it when the method exits (even if an exception is thrown) - so the code looks like this

    [Undo]
    void foo()
    {
        lib.performsomeaction();
        lib.performsomeaction();
        lib.performsomeaction();
    }

It's a little more complicated to implement this than I am showing because I have ensure that all undo contexts are cleaned up even in cases where there are nested Undo contexts - but you get the idea.

Answer 5

Dependency Injection

Strictly speaking, dependency injection is nothing more than a crosscutting concern. A lot of dependency injection frameworks use a attribute-based programming style like this:

public class Car:IDisposable
{
    [Inject]
    public IGearBox Gearbox { get; set; }
   ...
}

The [Inject] attribute could also designed as an aspect without any dependency to an external framework.

Answer 6

Another classic example (like logging) is caching. But other examples are more interesting.

Answer 7

Design Pattern Implementation in Java and AspectJ (Hannemann and Kiczales): http://www.cs.ubc.ca/labs/spl/papers/2002/oopsla02-patterns.pdf

The paper shows how some of the GoF design patterns can implemented in a better way in Java using AspectJ

Answer 8

Security - checking that users have appropriate permissions prior to executing certain methods.

Answer 9

You cannot have multiple inheritance in Java. However by using AOP you can have "limited" multiple inheritance. Try to google this to see some examples.

I also agree with Eyvid. Hannemann and Kiczales paper is great for learning the basics on design patterns and getting some great AOP examples.

Answer 10

Transaction management.

To my mind, you do not want objects that may be part of a transaction to be aware that they are in a transaction. Using AOP, you can compose objects into transactions as required without the objects in the transaction needing to be aware of either the fact that they are in a transaction or even of the existence of the AOP framework.

Answer 11

Examples of AOP:

• A parser and evaluator for arithmetic expressions. This could have been programmed using the visitor pattern, but I believe that aspects are a better alternative.
• A simple text editor, in which some management tasks (e.g., maintaining the "file has changed" flag, and the window caption) are treated as separate aspects.
• A data structure for character strings, in which strings are represented as trees so that concatenation and substring selection can be implemented without copying. To maintain efficiency, the trees sometimes need to be rebalanced; the balancing code is treated as an aspect.

Let's imagine you want to log a message inside methods of your domain model:

Example: Logging without AOP:

namespace Examples\Forum\Domain\Model;

class Forum {

    /**
     * @Flow\Inject
     * @var \Examples\Forum\Logger\ApplicationLoggerInterface
     */
    protected $applicationLogger;

    /**
     * Delete a forum post and log operation
     *
     * @param \Examples\Forum\Domain\Model\Post $post
     * @return void
     */
    public function deletePost(Post $post) {
            $this->applicationLogger->log('Removing post ' . $post->getTitle(), LOG_INFO);
            $this->posts->remove($post);
    }

}

If you have to do this in a lot of places, the logging would become a part of you domain model logic. You would have to inject all the logging dependencies in your models. Since logging is nothing that a domain model should care about, this is an example of a non-functional requirement and a so-called cross-cutting concern.

With AOP, the code inside your model would know nothing about logging. It will just concentrate on the business logic.

Answer 12

Public invariant checking. Since PostSharp 1.5 will come with aspect inheritance, even through interfaces, it will give a lot of new opportunities.

Answer 13

My photo album uses aspectj for three things:

1. Implementing the observer "pattern" as a reusable piece of code.
2. Destroying a session for a specific type of call.
3. Setting dirty flags on DTOs when mutation occurs.

The first, in particular was pretty much straight out of a google tech talk on AOP. It's about modularity in a different way than most people consider. Definitely recommend watching that if you're interested in how to use it for good.

Answer 14

I have used aspect-oriented programming to implement a keyword search engine. It was more like an experiment, but it shows how AOP can be used for purposes other than logging and tracing.

Basically:
(i) The user of the engine marks his/her classes as KeywordSearchable,
(ii) The engine starts tracking the creation & destruction of these KeywordSearchable instances,
(iii) The engine extracts the keywords from these KeywordSearchable objects,
(iv) Given the objects and the keywords, the algorithm takes care of the search.

More details on this can be found at http://montrealistic.blogspot.com/2011/08/aspect-oriented-implementation-of.html.