Cet article démontre la mise en œuvre d'AOP en utilisant l'annotation AspectJ et la configuration XML à Spring
Ce qui suit est le projet Java qui implémente AOP en utilisant des annotations AspectJ
Le premier est le fichier applicationContext.xml situé sous le chemin de classe
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.springframework.org/schema/tx" xsi: schemalation = "http://www.spring http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop/aop://www.springframework.org/schema/aop/spring-aop-2.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd "> <! - Activer la prise en charge de l'aspectj pour l'annotation -> <aop: Aspectj-Autoproxy /> <Bean Id =" Usermanager "/> <Ebor id = "SecurityHandler" /> </ Beans>
Ensuite, il y a l'interface de la couche de service et la classe d'implémentation
package com.jadyer.annotation; Interface publique UserManager {public void addUser (String Username, String Motword); Public Void DeLuer (int userId); public String finseUserById (int userId); public void ModifyUser (int userId, String Username, String Motway); } / ** * L'UserManager ci-dessus est l'interface de la couche de service * L'UserManagerimpl suivant est la classe d'implémentation de l'interface de couche de service * / package com.jadyer.annotation; La classe publique UserManageRIMP implémente UserManager {public void addUser (String Username, String Motword) {System.out.println ("------- UserManageImpl.AdDuser () est invoqué ------"); } public void DeUser (int userId) {System.out.println ("-------- UserManageImpl.Deluser () est invoqué ------"); } public string finserUserById (int userId) {System.out.println ("------- userManageImpl.finDuserById () est invoqué ------"); retourner "vie au visage de fer"; } public void ModifyUser (int userId, String Username, String Motway) {System.out.println ("------- UserManageImpl.ModifyUser () est invoqué ------"); }} Vient ensuite la classe d'entrée marquée d'aspectj
package com.jadyer.annotation; import org.aspectj.lang.annotation.after; import org.aspectj.lang.annotation.aspect; import org.aspectj.lang.annotation.pointcut; @Aspect public class SecurityHandler {/ ** * Define Pointcut * @see Pointcut Le nom de Pointcut est addaddMethod (). Cette méthode n'a pas de valeur de retour et de paramètres * @see Cette méthode est un identifiant et ne l'appelle pas * / @pointcut ("EXECUTION (* ADD * (..))") // Faire correspondre toutes les méthodes commençant par Add private void addaddMethod () {}; /** * Define Advice * @see Indicates which Pointcut subscriptions our Advice applies to on Joinpoints*/ //@Before("addAddMethod()") @After("addAddMethod()") private void checkSecurity() { System.out.println("------【checkSecurity is invoked】------"); }} Enfin, la classe de test client
package com.jadyer.annotation; import org.springframework.context.ApplicationContext; import org.springframework.context.support.classPathxmlApplicationContext; / ** * Prise en charge du printemps pour AOP: adopte la méthode d'annotation * @SEE --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Préalable: Puisqu'il s'agit d'un proxy dynamique JDK, si vous souhaitez générer un proxy, la classe doit implémenter une interface * @SEE Si la classe n'a pas d'interface d'implémente et utilise toujours une implémentation AOP par défaut de Spring, une erreur se produira, donc une interface sera généralement tirée pour générer un proxy. C'est-à-dire développer l'habitude de la programmation orientée vers l'interface * @see ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Ajout du support d'annotation * @see * spring_home // dist // printemps.jar * @see * spring_home // lib // log4j // log4j-1.2.14.jar * @see * spring_home // lib // jakarta-commons // commons-logging.jar * @see * spring_home // lib // aspectj // *. Préoccupations croisées et établir la sécurité de sécurité ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (Usermanager) Factory.getBean ("Usermanager"); usermanager.adduser ("Zhang Qiling", "02200059"); }} Ce qui suit est le projet Java qui implémente AOP à l'aide de fichiers de configuration XML
Le premier est le fichier ApplicationContext-Clib.xml situé dans le répertoire racine de Src
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.springframework.org/schema/tx" xsi: schemalation = "http://www.spring http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop/aop://www.springframework.org/schema/aop/spring-aop-2.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd "> <! - Force Utilisation de Cglib Proxy -> <! - <AOP: Aspectj-Autoproxy Proxy-Target-class =" / "/" id = "userManager" /> <bean id = "SecurityHandler" /> <aop: config> <aop: aspect id = "securityaspect" ref = "SecurityHandler"> <aop: Pointcut id = "addDadMethod" expression = "EXECUTION (* add * (..))" /> <aop: avant la méthode = "CheckSecurit </aop: config> </ beans> <! - Faites correspondre toutes les méthodes à commencer par add (* add * (..)) correspondent à toutes les méthodes de toutes les classes sous com.jadyer.servcices.impl com.jadyer.services.impl. *. Add * (..)) || Exécution (* com.jadyer.services.impl. *. del * (..)) ->
Ensuite, il y a l'interface de la couche de service et la classe d'implémentation
Package com.jadyer.cglib; Interface publique UserManager {public void addUser (String Username, String Motword); Public Void DeLuer (int userId); public String finseUserById (int userId); public void ModifyUser (int userId, String Username, String Motway); } / ** * L'UserManager ci-dessus est l'interface de couche de service * L'intermanager implémentation suivant est la classe d'implémentation de l'interface de couche de service * / package com.jadyer.cglib; La classe publique UserManageImpl {// implémente UserManager {public void addUser (String Username, String Motword) {System.out.println ("------- UsermanagerImpl.AdDuser () est invoqué -----"); } public void DeUser (int userId) {System.out.println ("-------- UserManageImpl.Deluser () est invoqué ------"); } public String finserUserById (int userId) {System.out.println ("------ UserManageImpl.finSerById () est invoqué ------"); retourner "Zhang San"; } public void ModifyUser (int userId, string username, String Motway) {System.out.println ("------- UserManageImpl.ModifyUser () est invoqué ------"); }} Ensuite, la classe d'entrée spécifiée dans ApplicationContext-Clib.xml
Package com.jadyer.cglib; import org.aspectj.lang.joinpoint; / ** * Passez les informations d'appel client aux conseils * @SEE Vous pouvez ajouter un paramètre JOINPOINT aux conseils pour obtenir le nom de la méthode et la valeur du paramètre de l'appel client * @see à l'avenir, il y a moins de cas d'utilisation purement AOP pour écrire des choses comme celle-ci. Nous utilisons principalement les transactions fournies par Spring * @see Vous pouvez en savoir. Ce qui suit est l'exemple de code * / classe publique SecurityHandler {private void CheckSecurity (joinpoint joinpoint) {for (int i = 0; i <joinpoint.getArgs (). Length; i ++) {System.out.println (joinpoint.getargs () [i]); // Obtenez la valeur du paramètre de la méthode appelée par le client} system.out.println (joinpoint.getSignature (). GetName ()); // Obtenez le nom de la méthode appelée par le client System.out.println ("------ [vérification de la sécurité est invoqué] ------"); }} Enfin, la classe de test client
Package com.jadyer.cglib; import org.springframework.context.ApplicationContext; import org.springframework.context.support.classPathxmlApplicationContext; /** * @voir ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Héritage, il est préférable de ne pas utiliser la déclaration finale pour la classe cible * @SEE ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Parce que les cibles que nous procurons sont généralement des objets commerciaux * @see ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- public class Client {public static void main (String [] args) {applicationContext factory = new ClassPathXmlApplicationContext ("ApplicationContext-Clib.xml"); // Lorsque UsermanagerImpl met implémente l'interface Usermanager, Spring utilisera automatiquement le proxy dynamique JDK // Si le projet a introduit la bibliothèque CGLIB et forcé l'utilisation de la procuration CGLIB dans le fichier de configuration, le printemps n'utilisera que le proxy CGLIB // Usermanager Usermanager = (UserManager) factory.getBean ("usermanager"); // Parce que l'UsermanagerImpl n'implémente pas l'interface UserManager pour le moment, l'interface Usermanager ne peut pas être utilisée dans le type de réception.// la bibliothèque CGLIB a été introduite dans le projet. Bien que le proxy CGLIB ne soit pas obligé d'être utilisé dans le fichier de configuration, Spring utilisera automatiquement le proxy CGLIB UsermanagerImpl UserManager = (UsermanagerImpl) Factory.getBean ("UserManager"); usermanager.adduser ("Wu Sansheng", "02200059"); }}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.