目录

  一、基于XML装备的Spring AOP

  二、运用证明装备AOP

  三、AspectJ切点函数

  四、AspectJ告诉证明

  五、零装备实现Spring IoC与AOP

  六、示例下载

  AOP(Aspect Oriented Programming)面向切面编程,通过预编译格事务署和运行期动态署理实现程序功能的横向众模块统一控制的一种技术。AOP是OOP的补充,是Spring框架中的一个浸要实质。诈欺AOP可以对商业逻辑的各个限制进行隔离,从而使得商业逻辑各限制之间的耦合度降低,提高程序的可浸用性,同时提高了开发的效率。AOP可以分为静态织入与动态织入,静态织入即正正在编译前将需织入实质写入目标模块中,这样本钱非常高。动态织入则不需要改变目标模块。Spring框架实现了AOP,运用证明装备完成AOP比运用XML装备要越发便当与直观。上一篇漫笔中曾经详细讲了署理模式。

详解Spring实现AOP的众种格事务署

  一、基于XML装备的Spring AOP

   正正在讲证明实现AOP功能前先用前面学习过的运用xml装备Spring AOP功能,这样是为了对比以便更好的理解。

  1.1、新建一个Maven项目,添加援用,项目的pom.xml文件如下:

详解Spring实现AOP的众种格事务署

XML/HTML代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   
  5.   <groupId>com.zhangguo</groupId>  
  6.   <artifactId>Spring052</artifactId>  
  7.   <version>0.0.1-SNAPSHOT</version>  
  8.   <packaging>jar</packaging>  
  9.   
  10.   <name>Spring052</name>  
  11.   <url>http://maven.apache.org</url>  
  12.   
  13.   <properties>  
  14.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  15.         <spring.version>4.3.0.RELEASE</spring.version>  
  16.     </properties>  
  17.     <dependencies>  
  18.         <dependency>  
  19.             <groupId>junit</groupId>  
  20.             <artifactId>junit</artifactId>  
  21.             <scope>test</scope>  
  22.             <version>4.10</version>  
  23.         </dependency>  
  24.         <dependency>  
  25.             <groupId>org.springframework</groupId>  
  26.             <artifactId>spring-context</artifactId>  
  27.             <version>${spring.version}</version>  
  28.         </dependency>  
  29.         <dependency>  
  30.             <groupId>org.aspectj</groupId>  
  31.             <artifactId>aspectjweaver</artifactId>  
  32.             <version>1.8.9</version>  
  33.         </dependency>  
  34.         <dependency>  
  35.             <groupId>cglib</groupId>  
  36.             <artifactId>cglib</artifactId>  
  37.             <version>3.2.4</version>  
  38.         </dependency>  
  39.     </dependencies>  
  40. </project>  

   1.2、创建要被署理的Math类,代码如下:

Java代码
  1. package com.zhangguo.Spring052.aop01;  
  2.   
  3. /** 
  4.  * 被署理的目标类 
  5.  */  
  6. public class Math{  
  7.     //加  
  8.     public int add(int n1,int n2){  
  9.         int result=n1+n2;  
  10.         System.out.println(n1+"+"+n2+"="+result);  
  11.         return result;  
  12.     }  
  13.       
  14.     //减  
  15.     public int sub(int n1,int n2){  
  16.         int result=n1-n2;  
  17.         System.out.println(n1+"-"+n2+"="+result);  
  18.         return result;  
  19.     }  
  20.       
  21.     //乘  
  22.     public int mut(int n1,int n2){  
  23.         int result=n1*n2;  
  24.         System.out.println(n1+"X"+n2+"="+result);  
  25.         return result;  
  26.     }  
  27.       
  28.     //除  
  29.     public int div(int n1,int n2){  
  30.         int result=n1/n2;  
  31.         System.out.println(n1+"/"+n2+"="+result);  
  32.         return result;  
  33.     }  
  34. }  

  1.3、编辑AOP中需要运用到的告诉类Advices.java代码如下:

Java代码
  1. package com.zhangguo.Spring052.aop01;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4.   
  5. /** 
  6.  * 告诉类,横切逻辑 
  7.  * 
  8.  */  
  9. public class Advices {  
  10.       
  11.     public void before(JoinPoint jp){  
  12.         System.out.println("----------前置告诉----------");  
  13.         System.out.println(jp.getSignature().getName());  
  14.     }  
  15.       
  16.     public void after(JoinPoint jp){  
  17.         System.out.println("----------最终告诉----------");  
  18.     }  
  19. }  

  1.4、装备容器初始化时需要的XML文件,aop01.xml文件实质如下:

XML/HTML代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  4.     xmlns:p="http://www.springframework.org/schema/p"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  7.         http://www.springframework.org/schema/beans/spring-beans.xsd  
  8.         http://www.springframework.org/schema/aop  
  9.         http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">  
  10.          
  11.     <!-- 被署理对象 -->  
  12.     <bean id="math" class="com.zhangguo.Spring052.aop01.Math"></bean>  
  13.       
  14.     <!-- 告诉 -->  
  15.     <bean id="advices" class="com.zhangguo.Spring052.aop01.Advices"></bean>  
  16.       
  17.     <!-- aop装备 -->  
  18.     <aop:config proxy-target-class="true">  
  19.         <!--切面 -->  
  20.         <aop:aspect ref="advices">  
  21.             <!-- 切点 -->  
  22.             <aop:pointcut expression="execution(* com.zhangguo.Spring052.aop01.Math.*(..))" id="pointcut1"/>  
  23.             <!--结合告诉方法与切点 -->  
  24.             <aop:before method="before" pointcut-ref="pointcut1"/>  
  25.             <aop:after method="after" pointcut-ref="pointcut1"/>  
  26.         </aop:aspect>  
  27.     </aop:config>  
  28.   
  29. </beans>  

  1.5、测试代码Test.java如下:

Java代码
  1. package com.zhangguo.Spring052.aop01;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class Test {  
  7.   
  8.     public static void main(String[] args) {  
  9.         ApplicationContext ctx = new ClassPathXmlApplicationContext("aop01.xml");  
  10.         Math math = ctx.getBean("math", Math.class);  
  11.         int n1 = 100, n2 = 5;  
  12.         math.add(n1, n2);  
  13.         math.sub(n1, n2);  
  14.         math.mut(n1, n2);  
  15.         math.div(n1, n2);  
  16.     }  
  17.   
  18. }  

  运行结果:

详解Spring实现AOP的众种格事务署

  二、运用证明装备AOP

详解Spring实现AOP的众种格事务署

  2.1、正正在上一个示例中修改被署理的类Math,为了实现IOC扫描正正在Math类上证明了@Service并定名bean为math。相当于上一个示例中正正在xml装备文件中增加了一个bean,<!-- 被署理对象 --><bean id="math" class="com.zhangguo.Spring052.aop01.Math"></bean>,Math类的代码如下:

Java代码
  1. package com.zhangguo.Spring052.aop02;  
  2.   
  3. import org.springframework.stereotype.Service;  
  4.   
  5. /** 
  6.  * 被署理的目标类 
  7.  */  
  8. @Service("math")  
  9. public class Math{  
  10.     //加  
  11.     public int add(int n1,int n2){  
  12.         int result=n1+n2;  
  13.         System.out.println(n1+"+"+n2+"="+result);  
  14.         return result;  
  15.     }  
  16.       
  17.     //减  
  18.     public int sub(int n1,int n2){  
  19.         int result=n1-n2;  
  20.         System.out.println(n1+"-"+n2+"="+result);  
  21.         return result;  
  22.     }  
  23.       
  24.     //乘  
  25.     public int mut(int n1,int n2){  
  26.         int result=n1*n2;  
  27.         System.out.println(n1+"X"+n2+"="+result);  
  28.         return result;  
  29.     }  
  30.       
  31.     //除  
  32.     public int div(int n1,int n2){  
  33.         int result=n1/n2;  
  34.         System.out.println(n1+"/"+n2+"="+result);  
  35.         return result;  
  36.     }  
  37. }  

  2.2、修改告诉类Advices,代码中有3个证明,@Component表示该类的实例会被Spring IOC容器牵制;@Aspect表示声明一个切面;@Before表示before为前置告诉,通过参数execution声明一个切点,Advices.java代码如下所示:

Java代码
  1. package com.zhangguo.Spring052.aop02;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.annotation.After;  
  5. import org.aspectj.lang.annotation.Aspect;  
  6. import org.aspectj.lang.annotation.Before;  
  7. import org.springframework.stereotype.Component;  
  8.   
  9. /** 
  10.  * 告诉类,横切逻辑 
  11.  * 
  12.  */  
  13. @Component  
  14. @Aspect  
  15. public class Advices {  
  16.     @Before("execution(* com.zhangguo.Spring052.aop02.Math.*(..))")  
  17.     public void before(JoinPoint jp){  
  18.         System.out.println("----------前置告诉----------");  
  19.         System.out.println(jp.getSignature().getName());  
  20.     }  
  21.       
  22.     @After("execution(* com.zhangguo.Spring052.aop02.Math.*(..))")  
  23.     public void after(JoinPoint jp){  
  24.         System.out.println("----------最终告诉----------");  
  25.     }  
  26. }  

   上面的代码与下面的装备根蒂等同

XML/HTML代码
  1. <!-- 告诉 -->  
  2. <bean id="advices" class="com.zhangguo.Spring052.aop01.Advices"></bean>  
  3.   
  4. <!-- aop装备 -->  
  5. <aop:config proxy-target-class="true">  
  6.     <!--切面 -->  
  7.     <aop:aspect ref="advices">  
  8.         <!-- 切点 -->  
  9.         <aop:pointcut expression="execution(* com.zhangguo.Spring052.aop01.Math.*(..))" id="pointcut1"/>  
  10.         <!--结合告诉方法与切点 -->  
  11.         <aop:before method="before" pointcut-ref="pointcut1"/>  
  12.         <aop:after method="after" pointcut-ref="pointcut1"/>  
  13.     </aop:aspect>  
  14. </aop:config>

   2.3、新增装备文件aop02.xml,正正在装备IOC的基础上增加了aop:aspectj-autoproxy节点,Spring框架会自动为与AspectJ切面装备的Bean创建署理,proxy-target-class="true"属性表示被署理的目标对象是一个类,而非实现了接口的类,浸要是为了选择折柳的署理格事务署。

XML/HTML代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  4.     xmlns:p="http://www.springframework.org/schema/p"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xmlns:context="http://www.springframework.org/schema/context"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  8.         http://www.springframework.org/schema/beans/spring-beans.xsd  
  9.         http://www.springframework.org/schema/context  
  10.         http://www.springframework.org/schema/context/spring-context-4.3.xsd  
  11.         http://www.springframework.org/schema/aop  
  12.         http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">  
  13.         <context:component-scan base-package="com.zhangguo.Spring052.aop02">  
  14.         </context:component-scan>  
  15.         <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>  
  16. </beans>  

  2.4、测试运行代码Test.java如下:

Java代码
  1. package com.zhangguo.Spring052.aop02;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class Test {  
  7.   
  8.     public static void main(String[] args) {  
  9.         ApplicationContext ctx = new ClassPathXmlApplicationContext("aop02.xml");  
  10.         Math math = ctx.getBean("math", Math.class);  
  11.         int n1 = 100, n2 = 5;  
  12.         math.add(n1, n2);  
  13.         math.sub(n1, n2);  
  14.         math.mut(n1, n2);  
  15.         math.div(n1, n2);  
  16.     }  
  17.   
  18. }  

  运行结果:

详解Spring实现AOP的众种格事务署

  三、AspectJ切点函数

   切点函数可以定位到切实的横切逻辑位置,正正在前面的示例中银河文娱有哪些网站_云顶文娱场7610_bet9九州 网站只运用过execution(* com.zhangguo.Spring052.aop02.Math.*(..)),execution就是一个切点函数,但该函数只什么方法一级,如果银河文娱有哪些网站_云顶文娱场7610_bet9九州 网站要织入的范围是类或某个证明则execution就不那么好用了,其实一共有9个切点函数,有折柳的针对性。

  @AspectJ运用AspectJ分外的切点表达式描绘切面,Spring所支持的AspectJ表达式可分为四类:

  方法切点函数:通过描绘目标类方法信歇定义结合点。

  方法参数切点函数:通过描绘目标类方法入参信歇定义结合点。

  目标类切点函数:通过描绘目标类样板信歇定义结合点。

   署理类切点函数:通过描绘署理类信歇定义结合点。

  常睹的AspectJ表达式函数:

  execution():满足匹配模式字符串的所有目标类方法的结合点

  @annotation():任何标注了指定证明的目标方法链接点

   args():目标类方法运行时参数的样板指定结合点

  @args():目标类方法参数中是否有指定特定证明的结合点

  within():匹配指定的包的所有结合点

  target():匹配指定目标类的所有方法

  @within():匹配目标对象具有指定证明的类的所有方法

   @target():匹配当前目标对象样板的执行方法,其中目标对象持有指定的证明

  this():匹配当前AOP署理对象样板的所有执行方法

  最常用的是:execution(<修饰符模式>?<返回样板模式><方法名模式>(<参数模式>)<分外模式>?)切点函数,可以满足普及需求。

  为了展示各切点函数的功能现正正在新增一个类StrUtil,类如下:

Java代码
  1. package com.zhangguo.Spring052.aop03;  
  2.   
  3. import org.springframework.stereotype.Component;  
  4.   
  5. @Component("strUtil")  
  6. public class StrUtil {  
  7.     public void show(){  
  8.         System.out.println("Hello StrUtil!");  
  9.     }  
  10. }  

  测试代码如下:

Java代码
  1. package com.zhangguo.Spring052.aop03;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class Test {  
  7.   
  8.     public static void main(String[] args) {  
  9.         ApplicationContext ctx = new ClassPathXmlApplicationContext("aop03.xml");  
  10.         IMath math = ctx.getBean("math", Math.class);  
  11.         int n1 = 100, n2 = 5;  
  12.         math.add(n1, n2);  
  13.         math.sub(n1, n2);  
  14.         math.mut(n1, n2);  
  15.         math.div(n1, n2);  
  16.           
  17.         StrUtil strUtil=ctx.getBean("strUtil",StrUtil.class);  
  18.         strUtil.show();  
  19.     }  
  20.   
  21. }  

  3.1、切点函数execution,告诉与切面的定义如下:

Java代码
  1. package com.zhangguo.Spring052.aop03;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.annotation.After;  
  5. import org.aspectj.lang.annotation.Aspect;  
  6. import org.aspectj.lang.annotation.Before;  
  7. import org.springframework.stereotype.Component;  
  8.   
  9. /** 
  10.  * 告诉类,横切逻辑 
  11.  * 
  12.  */  
  13. @Component  
  14. @Aspect  
  15. public class Advices {  
  16.     @Before("execution(* com.zhangguo.Spring052.aop03.Math.*(..))")  
  17.     public void before(JoinPoint jp){  
  18.         System.out.println("----------前置告诉----------");  
  19.         System.out.println(jp.getSignature().getName());  
  20.     }  
  21.       
  22.     //execution切点函数  
  23.     //com.zhangguo.Spring052.aop03包下所有类的所有方法被切入  
  24.     @After("execution(* com.zhangguo.Spring052.aop03.*.*(..))")  
  25.     public void after(JoinPoint jp){  
  26.         System.out.println("----------最终告诉----------");  
  27.     }  
  28. }  

  运行结果如下:

详解Spring实现AOP的众种格事务署

   execution(<修饰符模式>?<返回样板模式><方法名模式>(<参数模式>)<分外模式>?)

   3.2、切点函数within

Java代码
  1. //within切点函数  
  2. //com.zhangguo.Spring052.aop03包下所有类的所有方法被切入  
  3. @After("within(com.zhangguo.Spring052.aop03.*)")  
  4. public void after(JoinPoint jp){  
  5.     System.out.println("----------最终告诉----------");  
  6. }  

详解Spring实现AOP的众种格事务署

   3.3、this切点函数

Java代码
  1. //this切点函数  
  2. //实现了IMath接口的署理对象的任意结合点  
  3. @After("this(com.zhangguo.Spring052.aop03.IMath)")  
  4. public void after(JoinPoint jp){  
  5.     System.out.println("----------最终告诉----------");  
  6. }  

详解Spring实现AOP的众种格事务署

    3.4、args切点函数

Java代码
  1. //args切点函数  
  2. //要求方法有两个int样板的参考才会被织入横切逻辑  
  3. @After("args(int,int)")  
  4. public void after(JoinPoint jp){  
  5.     System.out.println("----------最终告诉----------");  
  6. }  

详解Spring实现AOP的众种格事务署

  如果参数样板不是根蒂数据样板则需要包名。

  3.5、@annotation切点函数

   先自定义一个可以证明正正在方法上的证明

Java代码
  1. package com.zhangguo.Spring052.aop03;  
  2.   
  3. import java.lang.annotation.Documented;  
  4. import java.lang.annotation.ElementType;  
  5. import java.lang.annotation.Retention;  
  6. import java.lang.annotation.RetentionPolicy;  
  7. import java.lang.annotation.Target;  
  8.   
  9. @Target({ElementType.METHOD})  
  10. @Retention(RetentionPolicy.RUNTIME)  
  11. @Documented  
  12. public @interface MyAnno {  
  13. }  
Java代码
  1. //@annotation切点函数  
  2. //要求方法必须被证明com.zhangguo.Spring052.aop03.MyAnno才会被织入横切逻辑  
  3. @After("@annotation(com.zhangguo.Spring052.aop03.MyAnno)")  
  4. public void after(JoinPoint jp){  
  5.     System.out.println("----------最终告诉----------");  
  6. }  
Java代码
  1. package com.zhangguo.Spring052.aop03;  
  2.   
  3. import org.springframework.stereotype.Component;  
  4.   
  5. @Component("strUtil")  
  6. public class StrUtil {  
  7.     @MyAnno  
  8.     public void show(){  
  9.         System.out.println("Hello StrUtil!");  
  10.     }  
  11. }  

  运行结果:

详解Spring实现AOP的众种格事务署

  其它带@的切点函数都是针对质明的

  四、AspectJ告诉证明

   AspectJ告诉证明共有6个,常用5个,引介少用一些。

   先解决定义切点复用的问题,如下代码所示,切点函数的实质绝对往往:

Java代码
  1. package com.zhangguo.Spring052.aop04;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.annotation.After;  
  5. import org.aspectj.lang.annotation.Aspect;  
  6. import org.aspectj.lang.annotation.Before;  
  7. import org.springframework.stereotype.Component;  
  8.   
  9. /** 
  10.  * 告诉类,横切逻辑 
  11.  * 
  12.  */  
  13. @Component  
  14. @Aspect  
  15. public class Advices {  
  16.     @Before("execution(* com.zhangguo.Spring052.aop04.Math.*(..))")  
  17.     public void before(JoinPoint jp){  
  18.         System.out.println("----------前置告诉----------");  
  19.         System.out.println(jp.getSignature().getName());  
  20.     }  
  21.       
  22.     @After("execution(* com.zhangguo.Spring052.aop04.Math.*(..))")  
  23.     public void after(JoinPoint jp){  
  24.         System.out.println("----------最终告诉----------");  
  25.     }  
  26. }  

  可以先定义一个切点然后复用,如下所示:

Java代码
  1. package com.zhangguo.Spring052.aop04;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.annotation.After;  
  5. import org.aspectj.lang.annotation.Aspect;  
  6. import org.aspectj.lang.annotation.Before;  
  7. import org.aspectj.lang.annotation.Pointcut;  
  8. import org.springframework.stereotype.Component;  
  9.   
  10. /** 
  11.  * 告诉类,横切逻辑 
  12.  */  
  13. @Component  
  14. @Aspect  
  15. public class Advices {  
  16.     //切点  
  17.     @Pointcut("execution(* com.zhangguo.Spring052.aop04.Math.*(..))")  
  18.     public void pointcut(){  
  19.     }  
  20.       
  21.     @Before("pointcut()")  
  22.     public void before(JoinPoint jp){  
  23.         System.out.println("----------前置告诉----------");  
  24.         System.out.println(jp.getSignature().getName());  
  25.     }  
  26.       
  27.     @After("pointcut()")  
  28.     public void after(JoinPoint jp){  
  29.         System.out.println("----------最终告诉----------");  
  30.     }  
  31. }  

   修改Advices.java文件,增加种种告诉样板如下:

Java代码
  1. package com.zhangguo.Spring052.aop04;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5. import org.aspectj.lang.annotation.After;  
  6. import org.aspectj.lang.annotation.AfterReturning;  
  7. import org.aspectj.lang.annotation.AfterThrowing;  
  8. import org.aspectj.lang.annotation.Around;  
  9. import org.aspectj.lang.annotation.Aspect;  
  10. import org.aspectj.lang.annotation.Before;  
  11. import org.aspectj.lang.annotation.Pointcut;  
  12. import org.springframework.stereotype.Component;  
  13.   
  14. /** 
  15.  * 告诉类,横切逻辑 
  16.  */  
  17. @Component  
  18. @Aspect  
  19. public class Advices {  
  20.     //切点  
  21.     @Pointcut("execution(* com.zhangguo.Spring052.aop04.Math.a*(..))")  
  22.     public void pointcut(){  
  23.     }  
  24.       
  25.     //前置告诉  
  26.     @Before("pointcut()")  
  27.     public void before(JoinPoint jp){  
  28.         System.out.println(jp.getSignature().getName());  
  29.         System.out.println("----------前置告诉----------");  
  30.     }  
  31.       
  32.     //最终告诉  
  33.     @After("pointcut()")  
  34.     public void after(JoinPoint jp){  
  35.         System.out.println("----------最终告诉----------");  
  36.     }  
  37.       
  38.     //环绕告诉  
  39.     @Around("execution(* com.zhangguo.Spring052.aop04.Math.s*(..))")  
  40.     public Object around(ProceedingJoinPoint pjp) throws Throwable{  
  41.         System.out.println(pjp.getSignature().getName());  
  42.         System.out.println("----------环绕前置----------");  
  43.         Object result=pjp.proceed();  
  44.         System.out.println("----------环绕后置----------");  
  45.         return result;  
  46.     }  
  47.       
  48.     //返回结果告诉  
  49.     @AfterReturning(pointcut="execution(* com.zhangguo.Spring052.aop04.Math.m*(..))",returning="result")  
  50.     public void afterReturning(JoinPoint jp,Object result){  
  51.         System.out.println(jp.getSignature().getName());  
  52.         System.out.println("结果是:"+result);  
  53.         System.out.println("----------返回结果----------");  
  54.     }  
  55.       
  56.     //分外后告诉  
  57.     @AfterThrowing(pointcut="execution(* com.zhangguo.Spring052.aop04.Math.d*(..))",throwing="exp")  
  58.     public void afterThrowing(JoinPoint jp,Exception exp){  
  59.         System.out.println(jp.getSignature().getName());  
  60.         System.out.println("分外消歇:"+exp.getMessage());  
  61.         System.out.println("----------分外告诉----------");  
  62.     }  
  63. }  

  运行结果:

详解Spring实现AOP的众种格事务署

  五、零装备实现Spring IoC与AOP

  为了实现零装备正正在原有示例的基础上银河文娱有哪些网站_云顶文娱场7610_bet9九州 网站新增一个类User,如下所示:

Java代码
  1. package com.zhangguo.Spring052.aop05;  
  2.   
  3. public class User {  
  4.     public void show(){  
  5.         System.out.println("一个用户对象");  
  6.     }  
  7. }  

   该类并未证明,容器不会自动牵制。由于没有xml装备文件,则运用一个作为装备信歇,ApplicationCfg.java文件如下:

Java代码
  1. package com.zhangguo.Spring052.aop05;  
  2.   
  3. import org.springframework.context.annotation.Bean;  
  4. import org.springframework.context.annotation.ComponentScan;  
  5. import org.springframework.context.annotation.Configuration;  
  6. import org.springframework.context.annotation.EnableAspectJAutoProxy;  
  7.   
  8. @Configuration  //用于表示当前类为容器的装备类,雷同<beans/>  
  9. @ComponentScan(basePackages="com.zhangguo.Spring052.aop05")  //扫描的范围,相当于xml装备的结点<context:component-scan/>  
  10. @EnableAspectJAutoProxy(proxyTargetClass=true)  //自动署理,相当于<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>  
  11. public class ApplicationCfg {  
  12.     //正正在装备中声明一个bean,相当于<bean id=getUser class="com.zhangguo.Spring052.aop05.User"/>  
  13.     @Bean  
  14.     public User getUser(){  
  15.         return new User();  
  16.     }  
  17. }  

  该类的每一限制实质根蒂都与xml 装备有一对一的关系,请看注释,这样做要比写xml便当,但不便楬橥后修改。测试代码如下:

Java代码
  1. package com.zhangguo.Spring052.aop05;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  6.   
  7. public class Test {  
  8.   
  9.     public static void main(String[] args) {  
  10.         // 通过类初始化容器  
  11.         ApplicationContext ctx = new AnnotationConfigApplicationContext(ApplicationCfg.class);  
  12.         Math math = ctx.getBean("math", Math.class);  
  13.         int n1 = 100, n2 = 0;  
  14.         math.add(n1, n2);  
  15.         math.sub(n1, n2);  
  16.         math.mut(n1, n2);  
  17.         try {  
  18.             math.div(n1, n2);  
  19.         } catch (Exception e) {  
  20.         }  
  21.           
  22.         User user=ctx.getBean("getUser",User.class);  
  23.         user.show();  
  24.     }  
  25.   
  26. }  

  advices.java 同上,没有任何变化,运行结果如下:

详解Spring实现AOP的众种格事务署

  六、示例下载

  

除非特别注明,鸡啄米文章均为原创
转载请标明本文地址:http://www.sygjbus.cn/software/732.html
2017年5月27日
作家:鸡啄米 分类:软件开发 浏览: 评论:0