Aspect-oriented programming

Aspect-oriented programming

Aspect-oriented programming (AOP) is a programming paradigm that increases modularity by allowing the separation of cross-cutting concerns.

Separation of concerns entails breaking down a program into distinct parts (so-called "concerns", cohesive areas of functionality). All programming paradigms support some level of grouping and encapsulation of concerns into separate, independent entities by providing new abstractions (e.g. procedures, modules, classes, methods) that can be used to represent these concerns. But some concerns defy these forms of encapsulation and are called "crosscutting concerns" because they "cut across" multiple abstractions in a program.

Logging is the archetypal example of a crosscutting concern because a logging strategy necessarily affects every single logged part of the system. Logging thereby "crosscuts" all logged classes and methods.

All AOP implementations have some crosscutting expressions that encapsulate each concern in one place. The difference between implementations lies in the power, safety, and usability of the constructs provided. For example, interceptors that specify the methods to intercept express a limited form of crosscutting, without much support for type-safety or debugging. AspectJ has a number of such expressions and encapsulates them in a special class, an aspect. For example, an aspect can alter the behavior of the base code (the non-aspect part of a program) by applying advice (additional behavior) at various join points (points in a program) specified in a quantification or query called a pointcut (that detects whether a given join point matches). An aspect can also make binary-compatible structural changes to other classes, like adding members or parents.


Gregor Kiczales and his team at Xerox PARC originated the concept of AOP. This team also developed the first and most popular general-purpose language that supported AOP, AspectJ. IBM's research team emphasized the continuity of the practice of modularizing concerns with past programming practice, and offered the more powerful (but less usable) HyperJ and Concern Manipulation Environment, which have not seen wide usage. The examples in this article use AspectJ as it is the most widely known.

Motivation and basic concepts

Some code is "scattered" or "tangled", making it harder to understand and maintain. It is scattered when one concern (like logging) is spread over a number of modules (e.g., classes and methods). That means to change logging can require modifying all affected modules. Modules end up tangled with multiple concerns (e.g., account processing, logging, and security). That means changing one module entails understanding all the tangled concerns.

For example, consider a banking application with a conceptually very simple method for transferring an amount from one account to another [Note: The examples in this article appear in a syntax that is similar to that of the Java programming language.] : void transfer(Account fromAccount, Account toAccount, int amount) { if (fromAccount.getBalance() < amount) { throw new InsufficientFundsException(); } fromAccount.withdraw(amount); toAccount.deposit(amount); }

However, this transfer method overlooks certain considerations that would be necessary for a deployed application. It requires security checks to verify that the current user has the authorization to perform this operation. The operation should be in a database transaction in order to prevent accidental data loss. For diagnostics, the operation should be logged to the system log. And so on. A simplified version with all those new concerns would look somewhat like this:

void transfer(Account fromAccount, Account toAccount, int amount) throws Exception { if (!getCurrentUser().canPerform(OP_TRANSFER)) { throw new SecurityException(); } if (amount < 0) { throw new NegativeTransferException(); } Transaction tx = database.newTransaction(); try { if (fromAccount.getBalance() < amount) { throw new InsufficientFundsException(); } fromAccount.withdraw(amount); toAccount.deposit(amount); tx.commit(); systemLog.logOperation(OP_TRANSFER, fromAccount, toAccount, amount); } catch(Exception e) { tx.rollback(); throw e; } }

In the previous example other interests have become "tangled" with the basic functionality (sometimes called the "business logic concern"). Transactions, security, and logging all exemplify "cross-cutting concerns".

Also consider what happens if we suddenly need to change (for example) the security considerations for the application. In the program's current version, security-related operations appear "scattered" across numerous methods, and such a change would require a major effort.

Therefore, we find that the cross-cutting concerns do not get properly encapsulated in their own modules. This increases the system complexity and makes evolution considerably more difficult.

AOP attempts to solve this problem by allowing the programmer to express cross-cutting concerns in stand-alone modules called "aspects". Aspects can contain advice (code joined to specified points in the program) and inter-type declarations (structural members added to other classes). For example, a security module can include advice that performs a security check before accessing a bank account. The pointcut defines the times (join points) that a bank account can be accessed, and the code in the advice body defines how the security check is implemented. That way, both the check and the places can be maintained in one place. Further, a good pointcut can anticipate later program changes, so if another developer creates a new method to access the bank account, the advice will apply to the new method when it executes.

Join point models

The advice-related component of an aspect-oriented language defines a join point model (JPM). A JPM defines three things:

* When the advice can run. These are called "join points" because they are points in a running program where additional behavior can be usefully joined. A join point needs to be addressable and understandable by an ordinary programmer to be useful. It should also be stable across inconsequential program changes in order for an aspect to be stable across such changes. Many AOP implementations support method executions and field references as join points.
* A way to specify (or "quantify") join points, called "pointcuts". Pointcuts determine whether a given join point matches. Most useful pointcut languages use a syntax like the base language (e.g., Java signatures are used for AspectJ) and allow reuse through naming and combination.
* A means of specifying code to run at a join point. In AspectJ, this is called "advice", and can run before, after, and around join points. Some implementations also support things like defining a method in an aspect on another class.

Join point models can be compared based on the join points exposed, how join points are specified, the operations permitted at the join points, and the structural enhancements that can be expressed.

AspectJ's join point model

* The join points in AspectJ include method or constructor call or execution, the initialization of a class or object, field read and write access, exception handlers, etc. They do not include loops, super calls, throws clauses, multiple statements, etc.

* Pointcuts are specified by combinations of "primitive pointcut designators" (PCDs).

:"Kinded" PCDs match a particular kind of join point (e.g., method execution) and tend to take as input a Java-like signature. One such pointcut looks like this:

execution(* set*(*))

:This pointcut matches a method-execution join point, if the method name starts with "set" and there is exactly one argument of any type.

"Dynamic" PCDs check runtime types and bind variables. For example


:This pointcut matches when the currently-executing object is an instance of class Point. Note that the unqualified name of a class can be used via Java's normal type lookup.

"Scope" PCDs limit the lexical scope of the join point. For example


: This pointcut matches any join point in any type in the package. The "*" is one form of the wildcards that can be used to match many things with one signature.

Pointcuts can be composed and named for reuse. For example

pointcut set() : execution(* set*(*) ) && this(Point) && within(*);

:This pointcut matches a method-execution join point, if the method name starts with "set" and this is an instance of type Point in the package. It can be referred to using the name "set()".

* Advice specifies to run (before, after, or around) at a join point (specified with a pointcut) certain code (specified like code in a method). Advice is invoked automatically by the AOP runtime when the pointcut matches the join point. Here is an example of this: after() : set() { Display.update(); }::This is effectively saying, "if the "set()" pointcut matches the join point, run the code Display.update() after the join point completes."

Other potential join point models

There are other kinds of JPMs. All advice languages can be defined in terms of their JPM. For example a hypothetical aspect language for UML may have the following JPM:

* Join points are all model elements.

* Pointcuts are some boolean expression combining the model elements.

* The means of affect at these points are a visualization of all the matched join points.

Inter-type declarations

"inter-type declarations" provide a way to express crosscutting concerns affecting the structure of modules. Also known as open classes, this enables programmers to declare in one place members or parents of another class, typically in order to combine all the code related to a concern in one aspect. For example, if the crosscutting display-update concern were instead implemented using visitors, an inter-type declaration using the visitor pattern looks like this in AspectJ:

aspect DisplayUpdate { void Point.acceptVisitor(Visitor v) { v.visit(this); } // other crosscutting code... }

:This code snippet adds the acceptVisitor method to the Point class.

It is a requirement that any structural additions be compatible with the original class, so that clients of the existing class continue to operate, unless the AOP implementation can expect to control all clients at all times.


There are two different ways AOP programs can affect other programs, depending on the underlying languages and environments: (1) a combined program is produced, valid in the original language and indistinguishable from an ordinary program to the ultimate interpreter; and (2) the ultimate interpreter or environment is updated to understand and implement AOP features. The difficulty of changing environments means most implementations produce compatible combination programs through a process that has come to be known as "weaving". The same AOP language can be implemented through a variety of weaving techniques, so the semantics of a language should never be understood in terms of the weaving implementation. Only the speed of an implementation and its ease of deployment are affected by which method of combination is used.

Source-level weaving can be implemented using preprocessors (as C++ was implemented originally in CFront) that require access to program source files. However, Java's well-defined binary form enables bytecode weavers to work with any Java program in .class-file form. Bytecode weavers can be deployed during the build process or, if the weave model is per-class, during class loading. AspectJ started with source-level weaving in 2001, delivered a per-class bytecode weaver in 2002, and offered advanced load-time support after the integration of AspectWerkz in 2005.

Any solution that combines programs at runtime has to provide views that segregate them properly to maintain the programmer's segregated model. Java's bytecode support for multiple source files enables any debugger to step through a properly woven .class file in a source editor. However, some third-party decompilers are unable to process woven code because they expect code produced by Javac rather than all supported bytecode forms (see also "Problems", below).

Another alternative is deploy-time weaving [] . This basically implies post-processing, but rather than patching the generated code, this weaving approach "subclasses" existing classes so that the modifications are introduced by method-overriding. The existing classes remain untouched, even at runtime, and all existing tools (debuggers, profilers, etc.) can be used during development. A similar approach has already proven itself in the implementation of many Java EE application servers, such as IBM's WebSphere.


The following are some standard terminology used in Aspect-oriented programming:
* Cross-cutting concerns: Even though most classes in an OO model will perform a single, specific function, they often share common, secondary requirements with other classes. For example, we may want to add logging to classes within the data-access layer and also to classes in the UI layer whenever a thread enters or exits a method. Even though the primary functionality of each class is very different, the code needed to perform the secondary functionality is often identical.
* Advice: This is the additional code that you want to apply to your existing model. In our example, this is the logging code that we want to apply whenever the thread enters or exits a method.
* Pointcut: This is the term given to the point of execution in the application at which cross-cutting concern needs to be applied. In our example, a pointcut is reached when the thread enters a method, and another pointcut is reached when the thread exits the method.
* Aspect: The combination of the pointcut and the advice is termed an aspect. In the example below, we add a logging aspect to our application by defining a pointcut and giving the correct advice.

Comparison to other programming paradigms

Aspects emerged out of object-oriented programming and computational reflection. AOP languages have functionality similar to, but more restricted than metaobject protocols. Aspects relate closely to programming concepts like subjects, mixins, and delegation. Other ways to use aspect-oriented programming paradigms include Composition Filters and the hyperslices approach. Since at least the 1970s, developers have been using forms of interception and dispatch-patching that are similar to some of the implementation techniques for AOP, but these never had the semantics that the crosscutting specifications were written in one place.

Designers have considered alternative ways to achieve separation of code, such as C#'s partial types, but such approaches lack a quantification mechanism that allows reaching several join points of the code with one declarative statement.

Adoption risks

As with all immature technologies, widespread adoption of AOP is hindered by a lack of tool support, and widespread education. Some argue that slowing down is appropriate due to AOP's inherent ability to create unpredictable and widespread errors in a system. Implementation issues of some AOP languages mean that something as simple as renaming a function can lead to an aspect no longer being applied leading to negative side effects.

Programmers need to be able to read code and understand what's happening in order to prevent errors1. While they have grown accustomed to ignoring the details of method dispatch or container-supplied behaviors, many are uncomfortable with the idea that an aspect can be injected later adding behavior to their code. There are also valid security questions that code weaving raises.

Some programmers therefore object to all forms of bytecode weaving. AOP implementations are a particular concern for them because of its prevalence. One response in Java is to sign and seal the .jar files and prevent environments from deploying weaving class loaders affecting their code, but in some cases the deployment environment is not under their control.

Even with proper education, understanding crosscutting concerns can be difficult without proper support for visualizing both static structure and the dynamic flow of a program. Visualizing crosscutting concerns is just beginning to be supported in IDEs, as is support for aspect code assist and refactoring.

Given the power of AOP, if a programmer makes a logical mistake in expressing crosscutting, it can lead to widespread program failure. Conversely, another programmer may change the join points in a program -- e.g., by renaming or moving methods -- in ways that were not anticipated by the aspect writer, with unintended consequences. One advantage of modularizing crosscutting concerns is enabling one programmer to affect the entire system easily; as a result, such problems present as a conflict over responsibility between two or more developers for a given failure. Open questions of legal liability in such cases may also influence some to reject bytecode weaving altogether. However, the solution for these problems can be much easier in the presence of AOP, since only the aspect need be changed, whereas the corresponding problems without AOP can be quite difficult to fix.

Bytecode decompilation and weaving has grown as an implementation method for many approaches including model-based programming. Early implementations of that technology can address only the subset of Java bytecode produced by Javac, the standard compiler, and thus fail when encountering valid bytecode produced by weavers that would never be produced by Javac. These problems can take some time to sort out since there are few developers familiar with bytecode internals. In the meantime, programming teams might have to choose between two incompatible development technologies.

Using AOP judiciously to develop your own code can result in powerful succinct expressiveness. Using AOP to add to code written by someone else (especially when you don't have the source code) is risky. Since the risk is to code written by others, code weaving can be emotional for the authors of the original code. There is little moral grounding to guide programmers in these matters because morality isn't something often applied to coding practices. Until these matters are sorted out, widespread adoption of AOP is itself at risk.

Usage of supporting methodologies such as test-driven development or test automation can reduce some of the risks associated with employing AOP. Assurance that the aspect doesn't negatively impact the original author's intent can be verified through running tests. Employing AOP without such a safety net is frightening to many programmers, especially those who are not familiar with the methodologies employed by responsible practitioners of AOP.

The potential of AOP for creating malware should also be considered. If security is a cross cutting concern implemented through the application of AOP techniques, then it is equally possible that breaking security can be implemented through injecting additional code at an appropriate place. For example, consider the impact of injecting code to return true at the beginning of a password verification function that returns a boolean value. This means that all programmers using languages that can be subjected to AOP techniques need to be aware of the potential of AOP to compromise their systems.


* For C#/VB.NET:
** [ Aspect.NET]
** [ LOOM.NET]
** [ Enterprise Library 3.0 Policy Injection Application Block]
** [ Puzzle.NAspect]
** [ AspectDNG]
** [ Aspect#]
** [ Encase]
** [ Compose*]
** [ PostSharp] (see also their Wiki about [ AOP techniques on .NET] )
** [ Seasar.NET]
** [ DotSpect (.SPECT)]
** [ The Spring.NET Framework] as part of its functionality
** [ Wicca and Phx.Morph]
** [ An exhaustive analysis] on AOSD solutions for .NET is available from Twente University

* For Java:
** AspectJ ( [] )
** [ AspectWerkz (Now merged with AspectJ)]
** [ Azuki]
** [ CaesarJ]
** [ Compose*]
** [ Dynaop]
** [ JAC]
** [ Guice] as part of its functionality
** Jakarta Hivemind
** [ Javassist Home Page]
** [ JAsCo (and AWED)]
** [ JAML]
** [ JBoss AOP]
** [ LogicAJ]
** [ Object Teams]
** [ PROSE]
** [ The AspectBench Compiler for AspectJ (abc)]
** The Spring Framework as part of its functionality
** Seasar
** [ The JMangler Project]
** [ InjectJ]
** [ GluonJ]
** [ Steamloom]

* For Flash ActionScript 2.0
** [ as2lib]

* For C/C++:
** AspectC++ ( [] )
** [ XWeaver project]
** [ FeatureC++]
** [ AspectC]
** [ AspeCt-oriented C]
** [ Aspicere2]

* For Cobol:
** [ Cobble]

* For Cocoa:
** [ AspectCocoa]
* For ColdFusion:
** [ ColdSpring]

* For Common Lisp:
** [ AspectL]

* For Delphi:
** [ InfraAspect]

* For HVL:
** 'e' (IEEE 1647)

* For JavaScript:
** [ Ajaxpect]
** [ AOP Fun with JavaScript] (Replaced by Ajaxpect)
** [ jQuery AOP Plugin]
** [ Dojo Toolkit]
** [ Aspectes]
** [ AspectJS]
** [ Humax Web Framework]
** [ Cerny.js]
** [ Advisable]

* For Koala:
** AspectKoala

* For Common Lisp:
** [ AspectL]

* For Lua:
** [ AspectLua]

* For make:
** [ MAKAO]

* For ML:
** [ AspectML]

* For Perl:
** [ The Aspect Module]

* For PHP:
** [ PHPaspect]
** [ Aspect-Oriented PHP]
** [ Seasar.PHP]
** [ AOP API for PHP] - PHPClasses Repository
** [ Transparent PHP AOP] - PHPClasses Repository
** [ PHP-AOP]

* For Python:
** [ Aspyct AOP]
** [ Lightweight Python AOP]
** [ Logilab's aspect module]
** [ Python/Transwarp AOP Tutorial] (Replaced by PEAK)
** [ PEAK]
** [ Pythius]
** [ Spring Python's AOP module]
** [ Experimental aspect programming for PyPy]

* For Ruby:
** [ AspectR]
** [ Aquarium]

* For Squeak Smalltalk
** [ AspectS]
** [ MetaclassTalk]

* For XML:
** [ AspectXML]

* For UML 2.0:
** [ WEAVR]

* For More Info (real-world implementations):
** [ ]

ee also

* Aspect-Oriented Software Development
* Programming paradigms
* Stability Model
* Subject-oriented programming an alternative to Aspect-oriented programming
* Executable UML
* Decorator pattern
* Domain-driven design


*cite book
first = Gregor
last = Kiczales
coauthors = John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Lopes, Jean-Marc Loingtier, and John Irwin
year = 1997
title = Proceedings of the European Conference on Object-Oriented Programming, vol.1241
chapter = [ Aspect-Oriented Programming]
pages = pp.220&ndash;242
The paper originating AOP.
*cite book
first = Robert E.
last = Filman
authorlink = Robert E. Filman
coauthors = Tzilla Elrad, Siobhàn Clarke, and Mehmet Aksit
year =
title = Aspect-Oriented Software Development
id = ISBN 0-321-21976-7

*cite book
first = Renaud
last = Pawlak
authorlink = Renaud Pawlak
coauthors = Lionel Seinturier, and Jean-Philippe Retaillé
year =
title = Foundations of AOP for J2EE Development
id = ISBN 1-59059-507-6

*cite book
first = Ramnivas
last = Laddad
authorlink = Ramnivas Laddad
year =
title = AspectJ in Action: Practical Aspect-Oriented Programming
id = ISBN 1-930110-93-6

*cite book
first = Ivar
last = Jacobson
authorlink = Ivar Jacobson
coauthors = and Pan-Wei Ng
year =
title = Aspect-Oriented Software Development with Use Cases
id = ISBN 0-321-26888-1

* [ Aspect-oriented Software Development and PHP, Dmitry Sheiko, 2006]
*cite book
first = Siobhán
last = Clarke
authorlink = Siobhán Clarke
coauthors = and Elisa Baniassad
year = 2005
title = Aspect-Oriented Analysis and Design: The Theme Approach
id = ISBN 0-321-24674-8


# Edsger Dijkstra, [ "Notes on Structured Programming"] , pg. 1-2


External links

* [ Aspect-Oriented Software Development] (annual conference about AOP)
* [ AOSD Wiki] (Wiki specifically devoted to AOP)
* [ AspectJ Programming Guide]
* [ The AspectBench Compiler for AspectJ] (another Java implementation)
* [ Series of IBM developerWorks articles on AOP]
* [] (Source of information on AOP and its related technologies)
* [ A detailed series of articles about the basics of aspect-oriented programming and AspectJ]
* [ Introduction to Aspect Oriented Programming with RemObjects Taco]
* [ Constraint-Specification Aspect Weaver]
* [ Aspect- vs. Object-Oriented Programming: Which Technique, When?]
* [ Gregor Kiczales, Professor of Computer Science, explaining AOP] (57min, video)
* [ Aspect Oriented Programming in COBOL]
* [ Aspect Oriented Programming in Java with Spring Framework]
* [ A Wiki dedicated to AOP techniques on .NET]
* [,7211,36794,00.html AOP considered harmful (Forrester)]
* [ Early Aspects for Business Process Modeling (An Aspect Oriented Language for BPMN)]
* [ AOSD Graduate Course at Bilkent University]

Wikimedia Foundation. 2010.

Look at other dictionaries:

  • Aspect-oriented software development — (AOSD) is an emerging software development technology that seeks new modularizations of software systems. AOSD allows multiple concerns to be expressed separately and automatically unified into working systems.Traditional software development has …   Wikipedia

  • Subject-oriented programming — Programming paradigms Agent oriented Automata based Component based Flow based Pipelined Concatenative Concurrent computing …   Wikipedia

  • Object-oriented programming — Programming paradigms Agent oriented Automata based Component based Flow based Pipelined Concatenative Concurrent computing …   Wikipedia

  • Role-Oriented Programming — is a form of computer programming aimed at expressing things in terms which are analogous to our conceptual understanding of the world. This should make programs easier to understand and maintain. The main idea of role oriented programming is… …   Wikipedia

  • Language-oriented programming — is a style of computer programming, via metaprogramming in which, rather than solving problems in general purpose programming languages, the programmer creates one or more domain specific programming languages for the problem first, and solves… …   Wikipedia

  • Semantic-oriented programming — (SOP) in which you express your code directly in semantic meanings, most suitable to reflect your task. This means, that for each task you may need to add new semantic meanings, thus you ll need an extendable and configurable programming language …   Wikipedia

  • Template Oriented Programming — In computer programming, Template oriented programming (TOP) is a programming paradigm that focuses on templates to accomplish a programmer’s goals. Template oriented programming is a more general version of generic programming in which the… …   Wikipedia

  • Inheritance (object-oriented programming) — In object oriented programming (OOP), inheritance is a way to reuse code of existing objects, establish a subtype from an existing object, or both, depending upon programming language support. In classical inheritance where objects are defined by …   Wikipedia

  • Aspect (computer science) — In computer science, an aspect is a part of a program that cross cuts its core concerns, therefore violating its separation of concerns. For example, logging code can cross cut many modules, yet the aspect of logging should be separate from the… …   Wikipedia

  • Aspect (homonymie) — Cette page d’homonymie répertorie les différents sujets et articles partageant un même nom. Sommaire 1 Droit 2 Informatique 3 Lingu …   Wikipédia en Français

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”

We are using cookies for the best presentation of our site. Continuing to use this site, you agree with this.