Ceci est un article de synthèse sur la façon d'écrire des spécificateurs de coupes de points AOP. Veuillez noter que cet article ne couvre pas les détails de l'AOP, de la mise en œuvre d'Aspect ou des conseils. Veuillez consulter l'article de référence lié séparément.
environnement
référence
Les types de désignateurs de coupe de point AspectJ pris en charge par Spring AOP.
execution
for matching method execution join points, this is the primary pointcut designator you will use when working with Spring AOP
format
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
| Section Format | modèle | Remarques |
|---|---|---|
| modifiers-pattern | Qualificatif | Abréviation |
| ret-type-pattern | Type de retour | |
| declaring-type-pattern | Type de déclaration | Abréviation |
| name-pattern | Nom de la méthode | |
| param-pattern | Type de paramètre | |
| throws-pattern | Type d'exception | Abréviation |
Exemple
@Around("execution(public String com.example.*..*ServiceImpl.find*(String,Long,Long) throws Exception)")
^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
| | | | | |
| | | | | +--- throws-pattern
| | | | +--- param-pattern
| | | +--- name-pattern
| | +--- declaring-type-pattern
| +--- ret-type-pattern
+--- modifiers-pattern
Cette condition correspond à la méthode findOne de la classe ci-dessous.
Exemple
package com.example.service.impl;
@Service
public class EvianServiceImpl implements EvianService {
//...réduction
public String findOne(String title, Long id, Long price) throws Exception {
//...réduction
}
}
modifiers-pattern
Spécifiez le qualificatif. public est facultatif. Cependant, étant donné que Spring AOP ne prend en charge que les méthodes publiques, il n'est pas nécessaire de le spécifier explicitement.
Exemple_(Description omise)
@Around("execution(String *..*ServiceImpl.find*(String,Long,Long) throws Exception)")
Due to the proxy-based nature of Spring’s AOP framework, calls within the target object are by definition not intercepted. For JDK proxies, only public interface method calls on the proxy can be intercepted. With CGLIB, public and protected method calls on the proxy will be intercepted, and even package-visible methods if necessary. However, common interactions through proxies should always be designed through public signatures.
ret-type-pattern
Spécifie le modèle de retour. Si vous n'avez pas besoin de spécifier le type, vous pouvez l'écrire avec "*".
Exemple_(Valeur de retour*Décrit dans)
@Around("execution(* *..*ServiceImpl.find*(String,Long,Long) throws Exception)")
declaring-type-pattern
Spécifiez le nom du package et le modèle de nom de classe. Il peut être spécifié par correspondance partielle comme décrit. Il peut être omis.
Exemple_(Description omise)
@Around("execution(public String find*(..) throws Exception)")
name-pattern
Spécifiez le modèle de nom de méthode. Comme mentionné ci-dessus, il peut être spécifié par correspondance partielle.
Exemple_(Décrivez le nom de la méthode avec une correspondance partielle)
find*(..)
Bien sûr, vous pouvez également écrire sans l'omettre.
Exemple_(Description non omise)
findOne(..)
param-pattern
Spécifie le modèle de paramètre. Il y a plusieurs manières de le décrire, mais vous pouvez l'écrire comme ".." si vous n'avez pas besoin de le spécifier.
Exemple
@Around("execution(* *..*ServiceImpl.find*(..) throws Exception)")
Lors de la spécification partielle. Lorsque le premier argument est String et que le deuxième type et les suivants sont arbitraires (aucun argument n'est nécessaire).
Exemple
find*(String,..)
Si le nombre d'arguments est fixe mais que le type n'est pas fixe, utilisez des caractères génériques.
Exemple
find*(*,*,*)
En ne prenant aucun argument.
Exemple
find*()
throws-pattern
Spécifie le modèle d'exception. Vous pouvez également spécifier par correspondance partielle du nom.
Exemple
@Around("execution(* *..*ServiceImpl.find*(..) throws *Exception)")
Il peut être omis.
Exemple
@Around("execution(* *..*ServiceImpl.find*(..))")
within
limits matching to join points within certain types (simply the execution of a method declared within a matching type when using Spring AOP)
S'applique aux méthodes de la classe spécifiée par FQCN.
OK
@Around("within(com.example.service.impl.WeatherServiceImpl)")
S'applique aux méthodes de la classe sous le package spécifié.
OK
@Around("within(com.example.service.impl.*)")
S'applique aux méthodes de la classe spécifiée.
OK
@Around("within(*..WeatherServiceImpl)")
Vous ne pouvez pas spécifier une interface.
NG
@Around("within(com.example.service.WeatherService)")
public interface WeatherService {
//...réduction
}
L'intérieur ne peut pas être lié.
@within
limits matching to join points within types that have the given annotation (the execution of methods declared in types with the given annotation when using Spring AOP)
'@within' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.
S'applique aux méthodes de la classe avec l'annotation spécifiée.
OK
@Around("@within(com.example.annotation.AopWithin)")
Exemple
@AopWithin
@Service
public class WeatherServiceImpl implements WeatherService {
//...réduction
}
Vous pouvez lier des annotations aux conseillers.
OK
@Around("@within(aopWithin)")
public Object w4(ProceedingJoinPoint pjp, AopWithin aopWithin) throws Throwable {
//...réduction
}
target
limits matching to join points (the execution of methods when using Spring AOP) where the target object (application object being proxied) is an instance of the given type
'target' is more commonly used in a binding form :- see the following section on advice for how to make the target object available in the advice body.
S'applique aux méthodes de l'interface spécifiée ou de la classe d'implémentation de la classe abstraite.
OK
@Around("target(com.example.service.AbstractService)")
Vous pouvez lier l'interface à un conseiller.
OK
@Around("target(service)")
public Object t2(ProceedingJoinPoint pjp, AbstractService service) throws Throwable {
//...réduction
}
Étant donné que la source de données est également une interface, elle peut être appliquée aux méthodes de la source de données comme indiqué ci-dessous.
Exemple
@Around("target(datasource)")
public Object b1(ProceedingJoinPoint pjp, DataSource datasource) throws Throwable {
//...réduction
}
@target
limits matching to join points (the execution of methods when using Spring AOP) where the class of the executing object has an annotation of the given type
'@target' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.
Je ne suis pas sûr. J'ai cherché, mais je n'ai pas compris.
args
'args' is more commonly used in a binding form :- see the following section on advice for how to make the method arguments available in the advice body.
S'applique aux méthodes qui acceptent l'argument spécifié. Si vous définissez args seul, une erreur d'exécution se produira, nous réduisons donc la cible avec l'exécution.
Dans cet exemple, il est appliqué à une méthode qui prend une classe appelée WeatherForm comme argument.
OK
@Around("execution(* com.example.*..*.*(..)) && args(com.example.form.WeatherForm)")
La séquence d'arguments spécifiée pour args est importante. Si vous voulez prendre un argument autre que WeatherForm, vous devez spécifier l'argument ou ajouter "..".
Exemple
@Around("execution(* com.example.*..*.*(..)) && args(com.example.form.WeatherForm,..)")
Vous pouvez lier les arguments au conseiller.
OK
@Around("execution(* com.example.*..*.*(..)) && args(form,..)")
public Object a2(ProceedingJoinPoint pjp, WeatherForm form) throws Throwable {
//...réduction
}
@args
'@args' can also be used in a binding form :- see the following section on advice for how to make the annotation object(s) available in the advice body.
S'applique aux méthodes qui prennent un objet de la classe avec l'annotation spécifiée comme argument.
OK
@Around("execution(* com.example.*..*.*(..)) && @args(com.example.annotation.AopTest)")
Exemple
@AopTest
public class WeatherForm implements Serializable {
//...réduction
}
Il ne peut pas être appliqué (il ne prend pas effet) en spécifiant une annotation dans l'argument de la méthode comme indiqué ci-dessous.
NG
public void forecast(@AopTest WeatherForm form) {
//...réduction
}
Vous pouvez lier des annotations aux conseillers.
OK
@Around("execution(* com.example.*..*.*(..)) && @args(aopTest)")
public Object a4(ProceedingJoinPoint pjp, AopTest aopTest) throws Throwable {
//...réduction
}
bean
Spécifiez par le nom du bean géré par le conteneur Spring. Vous pouvez utiliser des caractères génériques dans le nom. Cet exemple s'applique à une méthode bean se terminant par "ServiceImpl".
Exemple
@Around("bean(*ServiceImpl)")
@annotation
'@annotation' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.
S'applique à la méthode avec l'annotation spécifiée.
OK
@Around("@annotation(com.example.annotation.AopTest)")
Exemple
@AopTest
public void beforeTransaction() {
//...réduction
}
Vous pouvez lier des annotations aux conseillers.
OK
@Around("@annotation(aopTest)")
public Object a2(ProceedingJoinPoint pjp, AopTest aopTest) throws Throwable {
//...réduction
}
À partir de septembre 2017
The full AspectJ pointcut language supports additional pointcut designators that are not supported in Spring. These are: call, get, set, preinitialization, staticinitialization, initialization, handler, adviceexecution, withincode, cflow, cflowbelow, if, @this, and @withincode. Use of these pointcut designators in pointcut expressions interpreted by Spring AOP will result in an IllegalArgumentException being thrown.
Recommended Posts