AspectJ - Basic

AspectJ Basics Covers the understanding of AspectJ basic concepts:

• Know what a Cross Cutting Concern (CCC) is
• Understand the advantages and disadvantages of using aspect oriented programming
• Differentiate and identify basic join points, namely call, execution, get and set
• Understanding that CCCs can appear in other programming languages, modelling languages and use cases (or just about any structured document).

Programming AspectJ theory Covers theoretical basic knowledge of AspectJ :

• Understand what an advice does, and how to use before, after and around advice in various scenarios
• Understand the weaving process :
  • Define load time and compile time weaving
  • Explain why the classes exposed to be weaved must be exposed to the weaver
• Know that aspects can be declared using a specific grammar or in common Java using annotations

Basic AspectJ grammar Covers basic knowledge of AspectJ grammar :

• Write code that defines an aspect
• Write code that defines simple pointcuts
  • Using call, execution, get and set
  • Using class and member patterns
• Define and use a named pointcut
• Detect the differences between call and execution join points, one of the most common beginner problems.
• Write code that defines an advice, using either before, after or around

More about AspectJ aspects Covers more advanced topics about aspects in general :

• Write code using aspect libraries
• Write and aspect extending an abstract aspect
• Write code using AspectJ API and Java extension, namely proceed() and thisJoinPoint
• Write a pointcut combining different pointcuts and understand how to use && and || in pointcuts.

Parameters Covers extraction of parameters from pointcuts and usage of parameters in advice :

• Use the args() pointcut to extract parameters
• Use this() and target()
• Declare an advice with parameters and bind them to those declared in a pointcut

Basic intertype declarations Covers how AspectJ can be used to define a member of an existing class that conceptually belongs to a crosscutting concern (i.e., an aspect)

• Define a new field on an existing class
• Define a new method on an existing class
• Define an annotation on an existing class or class member
• Define a new interface on an existing class
• Explain how the access modifiers (private, protected etc..) present in Java have different semantics when applied to intertype declared members. Especially, how a private field will be private to the aspect, and not the target class.

@AspectJ style Covers how to use annotations to define aspects

• Know that @AspectJ style only allows compilable Java code
• Write code style aspects translating from @AspectJ style aspects