Aspect Instantiation Models

This is an advanced topic. If you are just starting out with AOP, you can safely skip it until later.

By default, there is a single instance of each aspect within the application context. AspectJ calls this the singleton instantiation model. It is possible to define aspects with alternate lifecycles. Spring supports AspectJ’s perthis, pertarget, and pertypewithin instantiation models; percflow and percflowbelow are not currently supported.

You can declare a perthis aspect by specifying a perthis clause in the @Aspect annotation. Consider the following example:

Java
Kotlin

@Aspect("perthis(execution(* com.xyz..service.*.*(..)))")
public class MyAspect {

	private int someState;

	@Before("execution(* com.xyz..service.*.*(..))")
	public void recordServiceUsage() {
		// ...
	}
}

@Aspect("perthis(execution(* com.xyz..service.*.*(..)))")
class MyAspect {

	private val someState: Int = 0

	@Before("execution(* com.xyz..service.*.*(..))")
	fun recordServiceUsage() {
		// ...
	}
}

In the preceding example, the effect of the perthis clause is that one aspect instance is created for each unique service object that performs a business service (each unique object bound to this at join points matched by the pointcut expression). The aspect instance is created the first time that a method is invoked on the service object. The aspect goes out of scope when the service object goes out of scope. Before the aspect instance is created, none of the advice within it runs. As soon as the aspect instance has been created, the advice declared within it runs at matched join points, but only when the service object is the one with which this aspect is associated. See the AspectJ Programming Guide for more information on per clauses.

The pertarget instantiation model works in exactly the same way as perthis, but it creates one aspect instance for each unique target object at matched join points.