Cette fois, j'aimerais écrire sur Spring AOP. Si vous souhaitez connaître les spécifications détaillées, veuillez lire Référence officielle. La version est Spring Boot 2.0.1.RELEASE (Spring 5.0.5.RELEASE).
AOP signifie ** Aspect Oriented Programming ** et est appelé "Aspect Oriented Programming". Dans AOP, écrivez du code pour séparer le traitement inter-classes (traitement des exceptions, journalisation, traitement des transactions, etc.) de la logique métier. Cela permet d'écrire simplement plusieurs processus et d'empêcher le code qui exécute le même processus d'être écrit à différents endroits.
Aspect Aspect est un module qui définit le transversal et où le faire. Au printemps, en ajoutant @Aspect à une classe, cette classe sera reconnue comme Aspect. Vous devez définir Aspect comme un bean, alors n'oubliez pas de le déclarer comme un bean avec @Component. (@Service et @Repository où @Component est déclaré en interne sont également OK.)
@Component
@Aspect
public class HogeAspect{
}
JoinPoint JoinPoint fait référence à l'endroit (méthode) où le processus transversal est inséré. PointCut PointCut est une représentation d'une collection de JoinPoints. Express PointCut en tant que paramètre de l'annotation Advice (décrite plus loin) comme indiqué dans l'exemple de code ci-dessous. Dans l'exemple ci-dessous, JoinPoint est spécifié par execution ().
@After(value = "execution(* com.example.fuga..Fuga.*(..))")
public void Hoge(/* .. */){
/* .. */
}
/*Au printemps, s'il n'y a pas d'autres paramètres, le paramètre nommé valeur "valeur"=Peut être omis, donc
@After("execution(* com.example.fuga..Fuga.*(..))")Vous pouvez également écrire.*/
Dans execution (), JoinPoint est exprimé par la syntaxe suivante.
execution(Valeur de retour Nom du package.nom de la classe.Nom de la méthode(Type d'argument))
/*
「*」 ->Représente une chaîne de caractères arbitraire. Cependant, lorsqu'il est utilisé comme nom de package, il représente "un package avec un nom arbitraire", et lorsqu'il est utilisé comme argument, il représente "un type arbitraire".
「..」 ->Lorsqu'il est utilisé comme nom de package, il représente "un package de 0 ou plus", et lorsqu'il est utilisé comme argument, il représente "tout type de 0 ou plus".
*/
Dans le premier exemple, il est exprimé que @After est appliqué à toutes les méthodes de la classe "Fuga" sous le package "com.example.fuga" (y compris les sous-packages) avec une valeur de retour arbitraire. Faire.
Outre l'exécution (), il existe diverses choses telles que within () et this (), mais execution () est souvent utilisée. Référence
Advice Le conseil représente le processus transversal lui-même exécuté par JoinPoint. En annotant une méthode d'une classe avec @Aspect, cette méthode peut être exécutée en tant que Advice. Il existe cinq types d'annotations qui représentent des conseils: @Before Conseil exécuté avant le traitement de la méthode cible.
@Before("execution(* *..*(..))")
public void beforeHandler(){
/* .. */
}
@After Conseil toujours exécuté quel que soit le résultat du traitement de la méthode cible.
@After("execution(* *..*(..))")
public void afterHandler(){
/* .. */
}
@AfterReturning Avis qui n'est exécuté que lorsque le traitement de la méthode cible est terminé avec succès. Si vous spécifiez une chaîne de caractères dans le paramètre de retour, la valeur de retour du traitement exécuté par JoinPoint est stockée dans la variable de cette chaîne de caractères. Cela permet à la valeur de retour d'être utilisée dans Advice.
@AfterReturning(value = "execution(* *..*(..))", returning = "r")
public void afterReturning(Object r){
System.out.println(r);
}
@AfterThrowing Avis qui n'est exécuté que lorsqu'une exception se produit lors du traitement de la méthode cible. Si vous spécifiez une chaîne dans le paramètre throwing, la variable de cette chaîne stocke l'exception qui s'est produite dans le processus exécuté par JoinPoint. Cela permet d'utiliser des exceptions dans les conseils.
@AfterThrowing(value = "execution(* *..*(..))", throwing = "e")
public void afterThrowing(Throwable e){
System.out.println(e.getMessage());
}
@Arround Conseils pouvant être exécutés à tout moment avant ou après le traitement de la méthode cible. Comme le montre l'exemple ci-dessous, le prétraitement et le post-traitement peuvent être définis librement.
@Arround("execution(* *..*(..))")
public void arround(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("Prétraitement")
//Exécution de la méthode
Object result = pjp.proceed();
System.out.println("Post-traitement")
}
Si vous utilisez Spring Boot, ajoutez "spring-boot-starter-aop" aux dépendances dans pom.xml. Si "spring-boot-starter-parent" est spécifié comme parent, il n'est pas nécessaire de spécifier la version de spring-boot-starter-aop car les informations de version ont déjà été définies.
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
</dependencies>
Si vous n'utilisez pas Spring Boot, vous pouvez l'utiliser en ajoutant «spring-aop» et «aspectjweaver» à pom.xml et en ajoutant @EnableAspectJAutoProxy à JavaConfig (opération non confirmée).
Créez une classe pour Aspect et préfixez la classe avec @Aspect et @Component.
@Component
@Aspect
public class HogeAspect{
}
Créez une méthode dans la classe définie comme Aspect. Annotez de manière appropriée l'avis décrit ci-dessus en fonction du moment de l'exécution de l'avis. En outre, utilisez execution () pour décrire dans quelle classe ou méthode l'avis créé est appliqué dans l'annotation Avis.
@Component
@Aspect
public class HogeAspect{
@AfterThrowing(value = "execution(* *..*(..))", throwing = "ex")
public void handler(Throwable ex){
/* .. */
}
}
Dans l'exemple ci-dessus, la gestion des exceptions est définie pour les exceptions qui se produisent dans toutes les méthodes.
https://docs.spring.io/spring/docs/5.0.5.RELEASE/spring-framework-reference/core.html#aop
Recommended Posts