Cet article présente la méthode d'utilisation du projet AOP dans Springboot. Je vais le partager avec vous. Les détails sont les suivants:
1. Présentation
L'utilisation de la logique générale pour mettre en œuvre la technologie AOP peut simplifier considérablement la rédaction de programmes, tels que la vérification de la signature, l'authentification, etc. Les transactions déclaratives de Spring sont également mises en œuvre via la technologie AOP.
Pour un code spécifique, veuillez vous référer à l'exemple de projet https://github.com/qihaiyan/springcamp/tree/master/spring-aop
La technologie AOP de Spring a quatre concepts de base:
PointCut: Point Cut, utilisé pour définir quelle méthode sera interceptée, par exemple l'exécution (* cn.springcamp.springaop.service. *. * (..))
Conseil: l'action à exécuter après avoir intercepté la méthode
Aspect: Coupez, combinez la coupe de points et conseils ensemble pour former une surface coupée
Point de jointure: une instance de coupe de points pendant l'exécution
Weaver: un cadre de mise en œuvre de l'AOP, comme AspectJ ou Spring AOP
2. Définition de définition
Les définitions de coups de points couramment utilisées incluent l'exécution et @annotation. L'exécution définit une méthode sans méthode et est utilisée pour implémenter une section relativement courante. @annotation peut être ajoutée comme annotation à des méthodes spécifiques, telles que l'annotation des transactions de Spring.
La définition de coupe du point d'exécution doit être placée dans une classe publique pour gérer de manière centralisée la définition de coupe ponctuelle.
Exemple:
classe publique CommonJoinpointConfig {@pointcut ("EXECUTION (* cn.springcamp.springaop.service. *. * (..))") public void ServiceLayeRexecution () {}}De cette façon, dans la classe d'aspect spécifique, vous pouvez vous référer au point tangent via CommonJoinpointConfig.ServiceLayEreXeUtion ().
classe publique BeforeAspect {@Before ("CommonJoinpointConfig.ServiceLayEreXecution ()") public void avant (joinpoint joinpoint) {System.out.println ("---------------> avant l'aspect"); System.out.println ("-----------------> Avant l'exécution de" + joinpoint); }}Lorsque le point tangent doit être modifié, il vous suffit de modifier la classe CommonJoinpointConfig, sans modifier chaque classe d'aspect.
3. Coupe de visage couramment utilisée
Avant: Exécutez des conseils avant l'exécution de la méthode, qui est souvent utilisée pour la vérification de la signature, l'authentification, etc.
Après: exécuter une fois l'exécution de la méthode terminée, que l'exécution soit réussie ou que l'exception soit lancée.
Après le retour: exécutez uniquement une fois l'exécution de la méthode réussie.
After-Thring: Exécutez uniquement après une méthode d'exécution lance une exception.
Un aspect simple:
@ Aspect @ ComponentPublic class beforeAspect {@Before ("CommonJoinpointConfig.ServiceLayeRexecution ()") public void avant (joinpoint joinpoint) {System.out.println ("---------------> Avant Aspect"); System.out.println ("----------------> Avant l'exécution de" + joinpoint); }}4. Annotations personnalisées
Supposons que nous voulons collecter le temps d'exécution d'une méthode spécifique, un moyen plus raisonnable consiste à personnaliser une annotation, puis à ajouter cette annotation à la méthode qui doit collecter le temps d'exécution.
Définissez d'abord un temps de piste d'annotation:
@Target ({elementType.Method, elementType.Type}) @ Rétention (RetenderPolicy.Runtime) public @Interface Tracktime {String Param () Default "";}Définissez ensuite une classe d'aspect pour mettre en œuvre le comportement de l'annotation:
@ Aspect @ ComponentPublic class tracktimeSpect {@around ("@ annotation (tracktime)") Objet public autour (procédingjoinpoint joinpoint, tracktime tracktime) lève throwable {object result = null; Long startTime = System.CurrentTimemillis (); result = joinpoint.proceed (); Long TimeTaken = System.Currenttimemillis () - Starmtime; System.out.println ("--------------> Temps pris par" + joinpoint + "avec param [" + tracktime.param () + "] est" + timetaken); Résultat de retour; }}En utilisant cette annotation sur une méthode, vous pouvez collecter le temps d'exécution de cette méthode:
@Tracktime (param = "myService") public String runfoo () {System.out.println ("----------------> foo"); retourner "foo";}Notez que l'annotation @tracktime (param = "myService") peut être transmise.
Pour que les annotations transmettent les paramètres, vous devez spécifier une chaîne de paramètre par défaut "par défaut" lors de la définition d'annotations.
Dans le même temps, dans la classe Aspect, les paramètres correspondants sont ajoutés à la méthode autour. Le nom de variable du paramètre est également nécessaire pour être en temps de piste dans l'annotation @around, mais pas le nom de classe de la classe.
@Around ("@ annotation (Tracktime)") Objet public autour (ProcedingJoinpoint JOINPOINT, Tracktime Tracktime)5. Résumé
Lors de l'exécution du projet d'échantillon, la console sortira ce qui suit:
----------------> avant l'aspect
--------------> Avant l'exécution de l'exécution (String cn.springcamp.springaop.service.myservice.runfoo ())
---------------> foo
---------------> temps pris par exécution (String cn.springcamp.springaop.service.myservice.runfoo ()) avec param [myservice] est 8
---------------> Après l'aspect
--------------> Après l'exécution de l'exécution (String cn.springcamp.springaop.service.myservice.runfoo ())
---------------> APRÈS ASPECT
----------------> EXÉCUTION (String cn.springcamp.springaop.service.myservice.runfoo ()) renvoyé avec valeur foo
On peut voir que l'ordre d'exécution de plusieurs aspects est avant après la remise en état (après -ère)
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.