Utilisateur:AlucardZeayon/BacASableTraduction

Un article de Wikipédia, l'encyclopédie libre.

AspectJ est une extension orientée aspect, créée à Xerox PARC, pour le langage de programmation Java. Cette extension est disponible dans les projets open-source Eclipse, de manière autonome ou sous forme d'extension pour l'environnement de développement Eclipse. AspectJ est devenu le standard, du fait de son utilisation répandue, pour la Programmation orientée aspect en mettant l'accent sur la simplicité et la facilité de mise en oeuvre pour les utilisateurs finaux. AspectJ se base sur la syntaxe du langage Java et s'intègre aux IDE pour afficher  crosscutting structure  ⇔  la structure de découpage depuis sa première publication en 2001. Le tissage d'aspect est géré de manière statique.

Sommaire

[modifier] Langage de description simple

Tout programme Java est compatible AspectJ. Toutefois, AspectJ permet également au programmeurs de définir des constructions spéciales nommées "aspects". Les "aspects" peuvent contenir plusieurs entités inutilisables par des classes standard. On trouve :

  • Déclaration inter-types - permet au programmeur d'ajouter des méthodes, champs ou interfaces à des classes existantes depuis l'"aspect". L'exemple suivant ajoute une méthode acceptVisitor (voir Visiteur (motif de conception)) à la classe Point :
aspect VisitAspect {
void Point.acceptVisitor(Visitor v) {
v.visit(this);
}
}


[modifier] Références

  • (en) Cet article est partiellement ou en totalité issu d’une traduction de l’article de Wikipédia en anglais intitulé « AspectJ ».


  • pointcuts — allow a programmer to specify join points (well-defined moments in the execution of a program, like method call, object instantiation, or variable access). All pointcuts are expressions (quantifications) that determine whether a given join point matches. For example, this point-cut matches the execution of any instance method in an object of type Point whose name begins with set:
pointcut set() : execution(* set*(..) ) && this(Point);
  • advice — allows a programmer to specify code to run at a join point matched by a pointcut. The actions can be performed before, after, or around the specified join point. Here, the advice refreshes the display every time something on Point is set, using the pointcut declared above:
after () : set() {
Display.update();
}

AspectJ also supports limited forms of pointcut-based static checking and aspect reuse (by inheritance). See the AspectJ Programming Guide for a more detailed description of the language.

[modifier] AspectJ compatibility and implementations

AspectJ has been designed to be implemented in many ways, including source- or bytecode-weaving and directly in the VM. In all cases, the AspectJ program is transformed into a valid Java program run in a Java VM. Any classes affected by aspects are binary-compatible with the unaffected classes (in order to maintain compatibility with any classes that were compiled with the unaffected originals). Supporting multiple implementations allows the language to grow as technology changes, and being Java-compatible ensures platform availability.

Key to its success has been engineering and language decisions designed to make the language usable and programs deployable. The original Xerox AspectJ implementation used source weaving, which required access to source code. When Xerox contributed the code to Eclipse, AspectJ was reimplemented using the Eclipse Java compiler and a bytecode weaver based on BCEL, so developers could write aspects for code in binary (.class) form. At this time the AspectJ language was restricted to support a per-class model essential for incremental compilation and load-time weaving. This made IDE integrations as responsive as their Java counterparts, and it enabled developers to deploy aspects without altering the build process. This led to increased adoption, as AspectJ became usable for impatient Java programmers and enterprise-level deployments. Since then, the Eclipse team has increased performance and correctness, upgraded the AspectJ language to support Java 5 language features like generics and annotations, and integrated annotation-style pure-java aspects from AspectWerkz.

The Eclipse project supports both command-line and Ant interfaces. A related Eclipse project has steadily improved the Eclipse IDE support (AJDT) for AspectJ and other providers of crosscutting structure. IDE support for emacs, NetBeans, and JBuilder foundered when Xerox put them into open source, but support for Oracle's JDeveloper did appear. IDE support has been key to ordinary Java programmers using AspectJ and understanding crosscutting concerns.

BEA has offered limited support in a VM for aspect-oriented extensions, but for extensions to be supported in all Java VM's would require agreement through Sun's Java Community Process (see also the java.lang.instrument package available since Java SE 5 which is some kind of common ground for JVM load-time instrumentation).

Academic interest in both the semantics and implementation of aspect-oriented languages has surrounded AspectJ since its release. The leading research implementation of AspectJ is the AspectBench Compiler, or abc; it supports extensions for changing the syntax and semantics of the language and forms the basis for many AOP experiments that the AspectJ team can no longer support, given its broad user base.

Many programmers discover AspectJ as an enabling technology for other projects they use, most notably Spring AOP.

[modifier] History and contributors

Gregor Kiczales started and led the Xerox PARC team that eventually developed AspectJ; he coined the term "crosscutting". Fourth on the team, Chris Maeda coined the term "aspect-oriented programming." Jim Hugunin and Erik Hilsdale (Xerox PARC team members 12 and 13) were the original compiler and weaver engineers, Mik Kersten implemented the IDE integration and started the Eclipse AJDT project with Adrian Colyer (current lead of the AspectJ project) and Andrew Clement (current compiler engineer).

Jonas Boner and Alex Vasseur engineered the AspectWerkz project, and later contributed to the AspectJ project when it merged in the AspectWerkz annotation style and load-time weaving support.

The AspectBench Compiler was developed and is being maintained as a joined effort of the Programming Tools Group at the Oxford University Computing Laboratory, the Sable Research Group at McGill University and the Institute for Basic Research in Computer Science (BRICS).

[modifier] See also

  • Aspect-oriented programming
  • AspectWerkz
  • Spring AOP (part of the Spring Framework)

[modifier] External links