1. Introduction
Pendant le processus de développement, nous devons souvent écrire de nombreux exemples:
@Getmapping ("/ id / get") Résultat public getbyId (String id) lève une exception {log.info ("Le paramètre de demande est:" + id); Vérifier (new VerifyParam ("Department ID", ID)); Résultat résultat = nouveau résultat ("obtenu avec succès via id!", Service.QueryById (id)); log.info ("Le message de retour est:" + result.toString ()); Résultat de retour; }Imprimer les paramètres de demande et les paramètres de retour, et ces opérations existent dans chaque méthode, ce qui rend notre code plus redondant. Pour cette raison, nous pouvons utiliser un proxy dynamique pour utiliser les paramètres d'impression et imprimer des messages de retour sous forme de sections, et utiliser des expressions de coupe ponctuelle pour les couper dans chaque méthode.
2. Étapes
1. Introduire des dépendances liées à l'AOP:
<! - Dépendances liées à AOP -> <dependency> <proupId> org.springframework.boot </proupId> <ArtefactId> printemps-boot-starter-aop </ artifactid> </Dependency>
Après avoir introduit des dépendances, Spring-AOP chargera les dépendances dont elle a besoin. Spring utilise AspectJ par défaut pour implémenter les notifications.
Parmi eux, AspectJweaver.jar contient des fichiers qui analysent les expressions de coupe ponctuelle AspectJ. Cette dépendance est également requise lors de l'utilisation d'expressions de coupe ponctuelle pour gérer les transactions.
2. Configuration:
1) Créez une classe de configuration:
/ ** * @Function Description: Classe AOP utilisée pour les opérations de calque de contrôleur * @Author Administrator * / @ Component // Gire les objets à ressortir pour la gestion @aspect // représente cette classe en tant que classe d'aspect ContromeLaOP {}L'annotation @aspect représente qu'il s'agit d'une classe de gestion d'aspect, où les expressions de coupe peuvent être définies, et le cadre AspectJ l'analysera.
2) Définir l'expression de coupe ponctuelle:
@Pointcut ("EXECUTION (public * com.hzt.manage. *. Web.Controller .. *. * (..))") // expression de points de point de privilège public () {}Où @pointcut représente cette méthode comme une expression de point de point. Sa valeur est une expression ponctuelle, où la valeur peut être omise et son format rugueux est:
@Annotation (Format d'expression d'expression + expression)
Pour le format, les indicateurs de coupe ponctuelle Aspectj soutenus par Spring AOP sont les suivants:
1. Exécution: le point de connexion utilisé pour correspondre à l'exécution de la méthode;
2. Dans: utilisé pour faire correspondre l'exécution des méthodes dans le type spécifié;
3. Ceci: méthode d'exécution utilisée pour faire correspondre le type d'objet proxy AOP actuel; Notez que la correspondance de type de l'objet proxy AOP, qui peut inclure l'introduction d'interfaces et de correspondance de type;
4. Target: méthode d'exécution utilisée pour correspondre au type d'objet cible actuel; Notez que la correspondance de type de l'objet cible est la correspondance de type, de sorte que l'introduction de l'interface n'est pas incluse;
5. Args: La méthode d'exécution est utilisée pour correspondre aux paramètres transmis par la méthode actuellement exécutée comme type spécifié;
6. @Within: utilisé pour faire correspondre les méthodes de maintenance dans le type d'annotation spécifié;
7. @Target: Méthode d'exécution utilisée pour correspondre au type d'objet cible actuel, où l'objet cible maintient l'annotation spécifiée;
8. @Args: utilisé pour faire correspondre l'exécution des paramètres passés dans la méthode actuellement exécutée qui contient l'annotation spécifiée;
9. @Annotation: utilisé pour faire correspondre la méthode qui exécute actuellement la méthode maintient l'annotation spécifiée;
10. Bean: Spring AOP Extension, AspectJ n'a pas de méthode d'exécution pour faire correspondre les objets Bean avec un nom spécifique;
11. Référence Pointcut: signifie se référer à d'autres points d'entrée de dénomination, seul le style @APECTJ le prend en charge, mais pas le style de schéma.
Args définit les paramètres lors de l'exécution de la méthode d'expression de coupe ponctuelle:
@Pointcut (value = "Exécution (public * com.hzt.manage. *. Web.Controller .. *. * (..)) && args (param)", argNames = "param") // expression de pointcut public void privilege1 (String Param) {}Nous nous concentrons sur l'expression du point de connexion de la méthode d'exécution, et sa structure approximative est:
Exécution (Modificateurs-Pattern? RET-Type-Pattern Declating-Type-Pattern? Name-Pattern (param-Pattern) lance-Pattern?)
1. Matchage du modificateur (Modificier-Pattern?) (Peut être omis)
2. La correspondance de valeur de retour (RET-Type-Pattern) peut représenter n'importe quelle valeur de retour pour *, telles que (String) ne représente que le filtrage du point d'entrée qui renvoie le type de chaîne, les noms de classe du chemin complet, etc. (ne peut pas être omis)
3. DÉCLARATION-LES-PATTERN? Par exemple, * .Manage représente le package de premier niveau comme arbitraire et le package de deuxième niveau comme le nom de la gestion. * .. Gérer représente les packages de sous-classe sous tous les packages Gérer. com .. *. Comtroller représente tous les packages de contrôleur sous packages com, etc., et * signifie que tous les packages correspondent. (Non omis)
4. La correspondance du nom de la méthode (Name-Pattern) peut spécifier le nom de la méthode ou * représente tout, GET * représente toutes les méthodes en commençant par GET, ou vous pouvez spécifier le préfixe * GET représente n'importe quelle méthode avec un suffixe arbitraire de GET (non omis)
5. La correspondance des paramètres ((param-motelle)) peut spécifier un type de paramètre spécifique, plusieurs paramètres sont séparés par "," et chaque paramètre peut également être "*" pour correspondre à tout type de paramètres, tels que (String) signifie une méthode pour correspondre à un paramètre de chaîne; (*, Chaîne) signifie une méthode pour correspondre à deux paramètres, le premier paramètre peut être de n'importe quel type et le deuxième paramètre est de type de chaîne; (..) peut être utilisé pour représenter n'importe quel paramètre (non omis)
6. Type d'exception correspondant (lancers-potentiel?)
3. Définissez la méthode des facettes
@Around ("privilEge ()") Objet public autour (ProcedingJoinpoint pjd) lève le throwable {// Obtenez le nom de méthode String className = pjd.getSignature (). GetClass (). GetName (); // Obtenez la méthode d'exécution Nom String MethodName = pjd.getSignature (). GetName (); / ** Initialisation log Impression * / logger log = loggerfactory.getLogger (className); // Définissez le paramètre de retour résultat objet = null; // Enregistrez l'heure de début start = System.currentTimemillis (); // Obtenir les paramètres de méthode objet [] args = pjd.getargs (); String params = "Les paramètres de demande frontale sont:"; // Obtenez la collecte des paramètres de demande et traversez et épissez pour (objet objet: args) {params + = object.toString () + ","; } params = params.substring (0, params.length () - 1); // Imprimez le paramètre de demande de demande log.info (className + "class" + méthodyname + "" + params); // Exécuter la méthode cible Résultat = pjd.proceed (); // Imprimez le journal de retour log.info ("La méthode renvoie le message comme:" + (Résultat des résultats de l'instance? (Résultat) Résultat: résultat)); // obtient le temps d'exécution log.info (méthodyname + "Le temps d'exécution de la méthode est:" + (system.currentTimeMillis () - start)); Résultat de retour; }5. @Around Surround Notification, comme indiqué dans le code ci-dessus, il s'agit de notification surround, qui a le paramètre ProvelingJoinpoint
Où le pjd.proceed (); La méthode représente l'exécution de la méthode cible et l'obtention d'une valeur de retour du type d'objet. Nous pouvons traiter la valeur de retour, comme le traitement de la décoration, etc.
La valeur du retour est le résultat de l'exécution de la méthode. Dans le code ci-dessus, obtient d'abord le nom de classe, le nom de la méthode, les paramètres de demande de méthode, etc., effectue l'impression d'épissage et enregistre l'heure de début de l'exécution de la méthode et l'imprime au journal.
Ensuite, exécutez la méthode, obtenez le résultat de retour de la méthode, imprimez le temps d'exécution et le résultat d'exécution.
Enfin, le résultat d'exécution est renvoyé. Autrement dit, le codage de la section AOP du message de demande et le message de retour est terminé.
Lorsque @around le représente comme une méthode de notification environnante, il a les types suivants:
1. @Before pré-notification, qui a le paramètre de demande JoinPoint, qui est utilisé pour connecter les détails de connexion du point de connexion actuel, y compris généralement le nom de la méthode et la valeur du paramètre. Le corps de la méthode est exécuté avant l'exécution de la méthode et les paramètres de la méthode ne peuvent pas être modifiés, ni les résultats de l'exécution de la méthode ne peuvent pas être modifiés.
@BeFore (value = "privilEge ()") public void avant (joinpoint joinpoint) {}2. @After Post Notification: Notification selon laquelle l'exécution est effectuée, peu importe si une exception se produit après l'exécution de la méthode cible. Dans la post-notification, le résultat d'exécution de la méthode cible ne peut pas être accessible (car une exception peut se produire) et le résultat d'exécution de la méthode ne peut pas être modifié.
@BeFore (value = "privilEge ()") public void après (joinpoint joinpoint) {}3. @Afterreturning Renvoie une notification. La notification qui est exécutée uniquement lorsque la méthode cible est exécutée est la même que la méthode post-arrangée. Il peut accéder au résultat de l'exécution de la méthode (en raison de l'exécution normale) et des détails de connexion de la méthode, mais ne peut pas modifier le résultat de l'exécution de la méthode.
@Afterreturning (value = "privilEge ()") public void afterreturning (joinpoint joinpoint, objet résultat) {}La valeur de retour stockée dans le résultat est la méthode.
4. @AfterThrowing Exception Notification: Code qui ne sera exécuté que lorsqu'une exception se produit dans la méthode cible. L'attribut de lancer représente une exception lancée lors de l'exécution du corps de la méthode, et sa valeur doit être cohérente avec la valeur de l'exception dans la méthode.
@AfterThrowing (value = "privilEge ()", throwing = "ex") public void exceed (joinpoint joinpoint, exception ex) {}3. Test
Écrivez une méthode de contrôleur
@ RestController @ requestmapping ("/ api / v1 / dept") classe publique DeptController étend BasEController {/ ** Logging class * / private logger log = loggerFactory.getLogger (getClass ()); / ** Mon propre service * / @Autowired Private DeptService Service; / ** * @Function Description: Méthode de requête du contenu du département basé sur ID * @return Dept * / @getMapping ("/ id / get") Public Result GetbyId (String id) exception {Verify (new Verifyparam ("Department ID", id)); Renvoie un nouveau résultat ("obtenu avec succès via ID!", Service.QueryById (ID)); }}De cette façon, la méthode de notre couche de contrôleur est grandement concise.
Résultats des tests:
2018-04-10 22: 59: 27.468 Info 1460 --- [NIO-8088-EXEC-5] nproceedingjoinpoint $ Methodsignaturempll: Le paramètre de demande frontal de Getbyid est: 22
2018-04-10 22: 59: 27.470 Info 1460 --- [Nio-8088-EXEC-5] nproceedingjoinpoint $ MethodsIgnatureImpl: La méthode renvoie le message en tant que: Result_Code = SUCH, result_Message = a réussi à obtenir les informations du département via id!, Data = Dept [id = 22, no = 22, nom = 22, manager = 22, description = 22, 22, 22, no = 22, CreateTime = jeu 19 avril 23:38:37 CST 2018, edittime = null]]
2018-04-10 22: 59: 27.470 Info 1460 --- [NIO-8088-EXEC-5] nproceedingjoinpoint $ Methodsignaturempll: Le temps d'exécution de la méthode Getbyid est: 2
Cela vous permet d'imprimer les paramètres de demande, les résultats de retour, le temps d'exécution, etc. avec une impression élégante, concise et concise!