Syntax for Defining Pointcut Expressions in Spring AOP
Spring AOP uses pointcut expressions to define where aspects should be applied. These expressions use wildcard patterns to match different method attributes. The syntax for pointcut expressions in Spring AOP is as follows:
1 | execution(modifier-pattern? return-type-pattern declaring-type-pattern? |
Components of Pointcut Expression
- execution: The keyword used to define a pointcut expression that targets method execution.
- modifier-pattern (optional): Matches method modifiers such as
public
,private
,protected
,static
, etc. If no specific modifier is needed, this part can be omitted. - return-type-pattern: Matches the method’s return type. Wildcard
*
can be used to match any return type, or specify a particular return type likevoid
,int
, etc. - declaring-type-pattern (optional): Matches the class that declares the method. Wildcards can match any class, or specify a particular class name.
- method-name-pattern: Matches the method name. Wildcard
*
can be used to match any method name, or specify a particular method name. - param-pattern: Matches the method parameters. Wildcard
*
matches any parameter, or specify the parameter types and names. - throws-pattern (optional): Matches the exceptions thrown by the method. Wildcard
*
can match any exception type, or specify particular exception types.
Examples
- Match all public methods in a specific package
1 | execution(public * com.example.service.*.*(..)) |
This pointcut expression will be applied to all public methods in the com.example.service
package.
public
: Matches public methods.*
: Matches any return type.com.example.service.*
: Matches all classes in thecom.example.service
package.*.*
: Matches any method name.(..)
: Matches any parameter list.
- Match methods with specific return type
1 | execution(* com.example.dao.*.find*(..)) |
This pointcut expression matches methods in the com.example.dao
package whose names start with find
.
*
: Matches any return type.com.example.dao.*
: Matches all classes in thecom.example.dao
package.find*
: Matches methods starting withfind
.(..)
: Matches any parameter list.
- Match methods with specific parameter types
1 | execution(* com.example.controller.*.*(String, ..)) |
This pointcut expression matches methods in the com.example.controller
package that have String
as the first parameter.
*
: Matches any return type.com.example.controller.*
: Matches all classes in thecom.example.controller
package.*.*
: Matches any method name.(String, ..)
: Matches methods withString
as the first parameter and any other parameters following it.
- Match methods in a specific class
1 | execution(* com.example.service.OrderService.*(..)) |
This pointcut expression matches all methods in the OrderService
class in the com.example.service
package.
*
: Matches any return type.com.example.service.OrderService
: Matches theOrderService
class.*
: Matches any method name.(..)
: Matches any parameter list.
Summary
By using pointcut expressions, you can precisely control where your aspects are applied, making your code more modular and easier to maintain. These expressions allow you to target specific methods based on their modifiers, return types, class names, method names, parameter types, and thrown exceptions.