Introduction
La programmation orientée orientée (AOP) fournit une autre perspective pour réfléchir à la structure du programme, qui compense les lacunes de la programmation orientée objet (POO). En plus des cours, AOP fournit des facettes. Modulariser l'objectif, tel que la gestion des transactions transversales de plusieurs types et objets. (Ces conditions de préoccupation sont souvent appelées préoccupations de coupe transversale.)
Un composant clé de Spring est le cadre AOP. Malgré cela, les conteneurs Spring IOC ne comptent pas sur AOP, ce qui signifie que vous êtes libre de choisir d'utiliser AOP. AOP fournit une puissante solution de middleware, ce qui rend les conteneurs Spring IOC plus complets.
Spring 2.0 AOP:
Spring 2.0 introduit un moyen plus simple et plus puissant de personnaliser la section, et les utilisateurs peuvent choisir d'utiliser des méthodes basées sur des schémas ou d'utiliser @AspectJ Annotations. Pour les nouvelles applications, si l'utilisateur se développe dans Java 5, nous recommandons que l'utilisateur utilise le style @aspectj, sinon le style basé sur le modèle peut être utilisé. Les deux styles soutiennent pleinement le type de conseils et le langage ponctuel de l'aspectj, bien qu'il soit toujours tissé à l'aide de Spring AOP.
Ce chapitre discute principalement de la prise en charge de Spring 2.0 pour AOP basé sur les modèles et @ AspectJ. Le printemps 2.0 conserve complètement la compatibilité vers l'arrière du printemps 1.2. Le chapitre suivant discutera du support AOP sous-jacent fourni par l'API Spring 1.2.
AOP utilisé au printemps:
Des services déclaratifs d'entreprise sont fournis, en particulier à la place des services déclaratifs de l'EJB. Le service le plus important est la gestion des transactions déclaratives, qui est construite sur l'abstraction des transactions abstraites de Spring.
Permet aux utilisateurs d'implémenter des sections personnalisées et d'utiliser AOP pour améliorer l'utilisation de la POO.
Exemple
Nous utilisons souvent les types suivants
1. AOP basé sur l'agent
2. Facettes d'objet Java pures et simples
3. @aspect Formulaire d'annotation
4. Appliquons les sections ASPCET dans le formulaire d'injection un par un.
Écrivons d'abord quelques cours de base.
Classe d'interface:
/ ** * Définir une interface * / interface publique Sleepable {/ ** * Méthode de sommeil * / void sleep (); } Classe d'implémentation:
/ ** * J'implémente l'interface de sommeil * / classe publique Chenllina implémente Sleepable {@Override public void sleep () {// TODO Method-généré par la méthode Stub System.out.println ("Soyez bon, il est temps d'aller au lit!"); }} Classe d'amélioration:
/ ** * Définissez une amélioration du sommeil pour réaliser la méthode avant et post-set * / public de classe publique implémente la méthode de ForfoReadvice, après la méthode de la méthode, l'objet [] @Override Public Void After Rereturning {System.out.out.println ("Appliquer un masque facal avant d'aller au lit"); } @Override public void avant (méthode de la méthode, objet [] args, objet Target) lève throwable {System.out.println ("rêve après avoir dormi"); }}1. AOP basé sur l'agent
<! - Créer un conseil amélioré -> <bean id = "Sleephelper" /> <bean id = "lina" /> <! - Définir une coupe ponctuelle correspond à toutes les méthodes de sommeil -> <bean id = "sleeppointcut"> <propriété name = "Pattern" value = ". * Sleep"> </ Property> </ank> <! - Définir une section ". <propriété name = "conseils" ref = "sleephelper" /> <propriété name = "Pointcut" ref = "sleepPointcut" /> </ bean> <! - Définissez un objet proxy -> <bean id = "linaproxy"> <propriété name = "cible" ref = "lina" /> <propriété name = "interceptora" name = "proxyInterfaces" value = "com.tgb.springaop.service.sleepable" /> -> </ank>
Comme dans le fichier de configuration:
L'attribut de modèle spécifie une expression régulière. Il correspond à toutes les méthodes de sommeil. Utilisez org.springframework.aop.support.defaultPointCutAdvisor pour combiner le point de tangent et l'amélioration pour former une tangente complète. Une fois la configuration finale terminée, un objet proxy final est généré via org.springframework.aop.framework.proxyfactoryBean.
2. Facettes d'objet Java pures et simples
Comment dire ces facettes d'objet Java purement simples? À mon avis, il est relatif à la première configuration, qui ne nécessite pas l'utilisation d'un proxy, mais analyse automatiquement le mécanisme interne du printemps. À l'heure actuelle, notre fichier de configuration doit être modifié comme suit:
<! - Créez un conseil amélioré -> <bean id = "Sleephelper" /> <! - Classe cible -> <bean id = "lina" /> <! - Configurer la coupe et les notifications -> <bean id = "Sleepadvisor"> <propriété name = "Conseil" Ref = "Sleephelper"> </ Property> <propriété Name = "Pattern" Valued = ". <Bean />
Est-ce beaucoup plus simple que le premier? Plus besoin de configurer le proxy?
3. @aspect Formulaire d'annotation
Sur la base de notre expérience, nous savons également que la forme d'annotations est plus simple que le fichier de configuration. Pour le moment, vous devez commenter les méthodes ou les classes existantes:
/ ** * Ajouter une amélioration via Annotation * / @aspect @Component Classe publique SleephelPer03 {/ * @ PointCut ("EXECUTION (* com.tgb.springaop.service.implt .. * (..))") * / @pointcut ("EXECUTION (* *. void beforeep () {System.out.println ("Appliquer un masque facial avant le sommeil"); } @Afterreturning ("sleepPoint ()") public void AfterSleep () {System.out.println ("Dream After Sleep"); }
Écrivez simplement dans le fichier de configuration:
<! - Scan Package -> <Context: Component-Scan Base-Package = "com.tgb" Annotation-Config = "True" /> <! - AspectJ Annotation-> <aop: AspectJ-Autoproxy Proxy-Target-Class = "True" /> <! - Target Class -> <Bean Id = "lina" />
4. surfaces coupées en Aspcet sous forme d'injection
Je pense personnellement que c'est le plus simple, le plus couramment utilisé et le plus flexible. Le fichier de configuration est le suivant:
<! - Target Class -> <bean id = "lina" /> <bean id = "sleephelper" /> <aop: config> <aop: aspect ref = "sleephelper"> <aop: avant méthode = "beforesleep" Pointcut = "Exécution (* * .sleep (..))" /> <aop: after method = "AfterSleep" Pointcut = "Execution (* *. </aop: aspect> </ aop: config>
La classe Sleephelper02 mentionnée dans le fichier de configuration est la suivante:
/ ** * Ajouter une amélioration à travers les annotations * / classe publique SleephelPer02 {public void beforesleep () {System.out.println ("Appliquer un masque facial avant de dormir"); } public void AfterSleep () {System.out.println ("Dream After Sleep"); }}
Cela semble-t-il très simple? Utilisez-vous tous Spring AOP? !
En ce qui concerne comment appeler, j'ai écrit plusieurs classes de test ici. Vous pouvez y jeter un œil. Ils sont fondamentalement les mêmes:
/ ** * Fichier de configuration Spring_aop.xml via proxy * / @test public void test () {applicationContext ct = new ClassPathXmlApplicationContext ("Spring_aop.xml"); Dormeur sommeil = (dorment) ct.getBean ("linaproxy"); dormeur.sleep (); } / ** * Fichier de configuration Spring_AOP_01.xml Réponse courte Objet Java * / @Test public void test01 () {applicationContext ct = new ClassPathXmlApplicationContext ("Spring_aop_01.xml"); Dormeur dorment = (dorment) ct.getBean ("lina"); dormeur.sleep (); } / ** * Fichier de configuration Spring_aop_03.xml Annotated by Aspect * / @Test public void test03 () {applicationContext ct = new ClassPathXmlApplicationContext ("spring_aop_03.xml"); Dormeur dorment = (dorment) ct.getBean ("lina"); dormeur.sleep (); } / ** * Fichier de configuration Spring_AOP_02.xml Fichier de configuration via APSECT * @Author Chen Lina * @version 31 mai 2015 à 10:09:37 AM * / @Test public Void Test02 () {ApplicationContext CT = New ClassPathxmlapplicationContext ("Spring_aop_02.xml"); Dormeur dorment = (dorment) ct.getBean ("lina"); dormeur.sleep (); }
À partir de la classe de test, nous pouvons voir que, quelle que soit la façon dont nous implémentons AOP, leur utilisation n'est pas différente. Les résultats de ces classes de test sont les mêmes: