SpringAOP
AOP représente la programmation orientée, qui est un complément de programmation orientée objet (OOP) est
Dans la programmation classique qui est nécessaire pour faire fonctionner les enregistrements du journal des transactions, peut être réalisé la réutilisation du code POO par héritage, etc.
AOP utilise un mécanisme d'extraction latérale, le code sera répétée en différents endroits de la dispersion est extrait, puis compiler ou de l'exécution, puis le code d'application extrait pour être effectuée lorsque cela est nécessaire.
AOP terminologie:
Aspect (section): Dans les applications pratiques, généralement, il se réfère section au fonctionnement du système d'emballage du type à insertion latérale
Joinpoint (points de connexion): un point d'étape lors de l'exécution du programme, il est en fait une cible de l'opération, comme les appels et exceptions méthodes jetés
Pointcut (point d'entrée): se réfère à l'intersection avec la section du flux de programme, le nom du point d'entrée se réfère à la classe ou méthode
L'avis (notification / amélioration): Procédé d'amélioration de la trame de AOP effectuée par un point d'entrée particulier, à savoir, les espaces définis point d'entrée de code de programme à exécuter.
TargetObject (Tout public cible): fait référence à tous les objets à notifier, aussi appelé une cible améliorée
Proxy (Proxy): après la notification de l'objet cible, l'objet est créé dynamiquement
Tissage (tissage): Le code de section dans l'objet cible, générant de ce fait un objet proxy du processus
proxy dynamique JDK:
proxy dynamique JDK est garantie par la classe java.lang.reflect.Proxy, vous pouvez appeler la méthode newProxyInstance classe Proxy () pour créer un objet proxy
étapes de mise en œuvre:
Ecrire Interface
Ecrire une classe de mise en œuvre
classe Cut pour écrire
// section de classe
public class {MyAspect
// Cette méthode est appelée amélioration
method1 public void () {
System.out.println ( "compte courant est correct.");
}
method2 public void () {
System.out.println ( "par la vérification ...");
}
}
Écrite classe proxy
public class {jdkProxy outils InvocationHandler
// Declare interface cible
privé UserDao userDao;
// Créer une méthode proxy
Objet createProxy (UserDao userDao) public {
this.userDao = userDao;
// 1, chargeur de classe
ClassLoader classLoader = jdkProxy.class.getClassLoader ();
// 2, l'objet proxy est mis en œuvre toutes les interfaces
Classe [] = claqq userDao.getClass () Les getInterfaces ().
// 3, en utilisant une classe proxy, objet amélioré après le retour de la chose proxy
retour Proxy.newProxyInstance (classLoader, claqq, this);
}
/ *
*
* Toutes les méthode de classe proxy dynamique est appelée, sera remis à Invoke () le traitement de la méthode
* Proxy est un objet qui représente l'agence
* Méthode Méthode doit être exécuté (par traitement de réflexion)
* La méthode d'exécution de Args est nécessaire
*
*
* /
@Passer outre
invocation publique de l'objet (proxy de l'objet, méthode Méthode, Object [] args)
jette Throwable {
// TODO stub méthode généré automatiquement
// Statement
MyAspect myAspect = new MyAspect ();
// il y améliorer
myAspect.method1 ();
// appeler la méthode sur la classe cible, et passer des paramètres
Objet obj = method.invoke (userDao, args);
// Après des améliorations
myAspect.method2 ();
retourner obj;
}
}
cours de test d'écriture
@Tester
Procédé public void () {
// Création d'un objet proxy
jdkProxy jdkProxy = new jdkProxy ();
// Création de l'objet cible
UserDao userDao = new UserDaoImpl ();
// Obtenez l'objet cible de l'objet proxy amélioré
UserDao userDao1 = (UserDao) jdkProxy.createProxy (userDao);
// méthode d'exécution
userDao.addUser ();
userDao.deleteUser ();
System.out.println ( "=========================================== === ");
userDao1.addUser ();
userDao1.deleteUser ();
}
Jdk mode proxy dynamique sera converti en springAop
Effacez la classe proxy a été reprise au printemps
Changer la MyAspect classe d'aspect
// section de classe
public class {MyAspect outils MethodInterceptor
// Cette méthode est appelée amélioration
method1 public void () {
System.out.println ( "compte courant est correct.");
}
method2 public void () {
System.out.println ( "par la vérification ...");
}
// A cette méthode proxy ici
@Passer outre
Invoke public Object (MethodInvocation mi) throws Throwable {
// TODO stub méthode généré automatiquement
method1 ();
// exécuter la méthode cible
Objet obj = mi.proceed ();
method2 ();
retourner obj;
}
}
fichier de configuration écriture
<! - 1, la classe cible ->
<Bean id = classe "userDao" = "com.bdqn.cn.dao.UserDaoImpl" />
<! - 2, section définitions de classe ->
<Bean id = classe "myAspect" = "com.bdqn.cn.aspect.MyAspect" />
<! - 3, en utilisant l'usine de proxy Spring pour définir un nom pour l'objet proxy userDaoProxy ->
<Bean id = classe "userDaoProxy" = "org.springframework.aop.framework.ProxyFactoryBean">
<! - Indique le proxy d 'exécution de l' interface ->
<Property name = valeur "de proxyInterfaces" = "com.bdqn.cn.dao.UserDao" />
<! - publics cibles ->
<Property name = "target" ref = "userDao" />
<! - Indique la section des notifications entourant l'implant ->
<Property name = valeur "de interceptorNames" = "myAspect" />
<! - Indique le mode proxy, si la valeur par défaut proxy dynamique jdk est vrai indication cglib ->
<Property name = value "proxyTargetClass" = "false" />
</ Bean>
cours de test d'écriture
@Tester
method2 public void () {
ApplicationContext app = new ClassPathXmlApplicationContext ( "applicationContext.xml");
UserDao ud = (UserDao) app.getBean ( "userDaoProxy");
ud.addUser ();
ud.deleteUser ();
}
