一起学Spring之AOP

概述

在软件开发中，我们重点关注的是业务逻辑代码，但在实际开发中，需要写的代码却不仅仅是业务逻辑，还需要处理记录日志，异常处理，事务控制等一些与业务无关的事情。而且这些代码也是服务端必须的，类似这样的代码分散在系统中的各个地方，如：几乎所有的重要操作方法前面都会加上日志记录代码，这样的代码写起来繁琐，又占用开发时间和精力，而且不容易维护。我们统一把这类代码成为【切面代码】，如何让我们从这些繁琐的工作中抽身而退，更加专注于业务逻辑，这就需要用到spring的aop技术。

aop原理：将复杂的需求分解成不同的方面，将散落在系统中的公共功能集中解决，如下图所示：

通知(advice)的分类

分类如下：

• 前置通知：在某个切入点之前执行的通知
• 后置通知：在某个切入点之后执行的通知
• 异常通知：在某个切入点出现异常时候的通知
• 环绕通知：包围某个切入点的通知，功能最强大

准备工作

aop需要的jar包

除spring必备的五个jar包外，还需要以下三个来支撑aop：

• aopalliance-1.0.jar
• aspectjweaver-1.5.3.jar
• spring-aop-4.0.6.release.jar

定义一个接口和实现类

如下所示：

istudentservice接口 代码如下：

 1 package com.hex.second;
 2 
 3 /**
 4  * 学生服务接口
 5  * @author administrator
 6  *
 7  */
 8 public interface istudentservice {
 9     
10     /**
11      * 新增学生
12      * @param student
13      */
14     void addstudent(student student);
15     /**
16      * 删除学生
17      * @param id
18      */
19     void deletestudent(int id);
20     
21     /**
22      * 修改学生
23      * @param id
24      */
25     void updatestudent(int id);
26 }

studentserviceimpl类 代码如下：

 1 package com.hex.second;
 2 
 3 /**
 4  * 学生服务事项类
 5  * @author administrator
 6  *
 7  */
 8 public class studentserviceimpl implements istudentservice {
 9 
10     /**
11      * 新增学生
12      */
13     public void addstudent(student student) {
14         // todo auto-generated method stub
15         system.out.println("新增加学生。。。");
16     }
17     
18     /**
19      * 删除学生
20      */
21     @override
22     public void deletestudent(int id) {
23         // todo auto-generated method stub
24         system.out.println("删除学生。。。");
25     }
26 
27     /**
28      * 修改学生
29      */
30     public void updatestudent(int id) {
31         // todo auto-generated method stub
32         system.out.println("修改学生");
33         int i=1/0;
34     }
35 }

前置通知

1. 实现接口

前置通知类，需要实现【methodbeforeadvice】接口中的before方法，如下所示：

method method 表示执行的目标方法

object[] args 表示传入的参数数组

object target 表示目标对象，即切入点所示的对象

 1 package com.hex.second;
 2 
 3 import java.lang.reflect.method;
 4 
 5 import org.springframework.aop.methodbeforeadvice;
 6 
 7 public class logbefore implements methodbeforeadvice {
 8 
 9     /***
10      * 前置通知
11      * method:表示调用的方法，即切入点
12      * args:表示调用方法的参数
13      * target：表示方法所在的目标对象
14      */
15     @override
16     public void before(method method, object[] args, object target) throws throwable {
17         // todo auto-generated method stub
18         system.out.println("前置通知。。。");
19         system.out.println("method="+method+",args数量="+args.length+",target="+target);
20     }
21 }

2. 配置applicationcontext.xml文件

如果要支持aop，需要引入命名空间，如下所示：

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.xsd">

3. 配置两个类对应的bean

1 <!-- 服务类 -->
2 <bean id="studentservice" class="com.hex.second.studentserviceimpl"></bean>
3 <!-- 前置通知类 -->
4 <bean id="logbefore" class="com.hex.second.logbefore"></bean>

4. 配置aop

通过aop配置，将通知类和业务逻辑类进行关联，说明如下：

一个配置文件中，可以有多个<aop:config>配置，每一个aop:config中只能有一个aop:pointcut配置，如果有多个切入点需要配置expression，且切入点必须是全路径配置。如下所示：

<!-- 将addstudent和通知进行关联 -->
<aop:config>
     <!-- 每一个config只有一个poingcut，如果有多个，则需要配置多个config -->
     <!-- 配置切入点  id自定义，expression表示切入点的函数名-->
     <aop:pointcut expression="execution(public void com.hex.second.studentserviceimpl.addstudent(com.hex.second.student))" id="pc"/>
     <!-- 配置通知 -->
     <aop:advisor advice-ref="logbefore" pointcut-ref="pc"/>
</aop:config>

后置通知

1. 实现接口

需要实现【afterreturningadvice】接口【afterreturning】方法中的 如下所示：

 1 package com.hex.second;
 2 
 3 import java.lang.reflect.method;
 4 
 5 import org.springframework.aop.afterreturningadvice;
 6 
 7 /**
 8  * 通过实现接口将普通类变成后置通知
 9  * @author administrator
10  *
11  */
12 public class logafter implements afterreturningadvice {
13 
14     /**
15      * 后置通知实现类
16      * returnvalue：返回值
17      * method:表示调用的方法，即切入点
18      * args:表示调用方法的参数
19      * target：表示方法所在的目标对象
20      */
21     @override
22     public void afterreturning(object returnvalue, method method, object[] args, object target) throws throwable {
23         // todo auto-generated method stub
24         system.out.println("后置通知。。。");
25         system.out.println("returnvalue="+returnvalue+",method="+method+",args数量="+args.length+",target="+target);
26     }
27 
28 }

2. 配置切入点和通知的bean

1 <bean id="studentservice" class="com.hex.second.studentserviceimpl"></bean>
2 <bean id="logafter" class="com.hex.second.logafter"></bean>

3. aop配置

如果前置通知和后置通知为同一个切入点，则可以配置在一个aop:config节点中，如下所示：

多个切入点用or连接，多个通知就配置多个aop:advisor

 1 <!-- 将addstudent和通知进行关联 -->
 2 <aop:config>
 3      <!-- 每一个config只有一个poingcut，如果有多个，则需要配置多个config -->
 4      <!-- 配置切入点  id自定义，expression表示切入点的函数名-->
 5      <aop:pointcut expression="execution(public void com.hex.second.studentserviceimpl.deletestudent(int)) or execution(public void com.hex.second.studentserviceimpl.addstudent(com.hex.second.student))" id="pc"/>
 6      <!-- 配置通知 -->
 7      <aop:advisor advice-ref="logbefore" pointcut-ref="pc"/>
 8          
 9      <aop:advisor advice-ref="logafter" pointcut-ref="pc"/>
10 </aop:config>

异常通知

1. 实现接口

异常通知是有异常发生时，才会触发的通知，需要实现【throwsadvice】接口，且此接口没有需要实现的方法，但同时给出了约定：

必须以固定格式实现方法：public void afterthrowing([method, args, target], throwablesubclass);

 1 package com.hex.second;
 2 
 3 import java.lang.reflect.method;
 4 
 5 import org.springframework.aop.throwsadvice;
 6 
 7 /**
 8  * 异常通知
 9  * @author administrator
10  *
11  */
12 public class logexception implements throwsadvice {
13     
14     /**
15      * 异常通知执行
16      * @param method 切入点
17      * @param args 参数个数
18      * @param target 调用目标对象
19      * @param ex 异常
20      */
21     public void afterthrowing(method method, object[] args, object target, exception ex){
22         system.out.println("异常通知。。。");
23         system.out.println("method="+method+",args数量="+args.length+",target="+target+",ex="+ex);
24     }
25 }

2. 配置bean类

1 <!-- 服务类 -->
2 <bean id="studentservice" class="com.hex.second.studentserviceimpl"></bean>
3 <bean id="logexception" class="com.hex.second.logexception"></bean>

3. 配置aop

如下所示：参数只需要写参数类型即可，不需要写参数名称

1 <!-- 可以配置aop:config -->
2 <aop:config>
3         <aop:pointcut expression="execution(public void com.hex.second.studentserviceimpl.updatestudent(int))" id="pc1"/>
4      <!-- 配置通知 -->
5      <aop:advisor advice-ref="logexception" pointcut-ref="pc1"/>
6 </aop:config>

环绕通知

1. 实现接口

环绕通知，需要实现【methodinterceptor】接口并实现【invoke】方法，其中obj = invocation.proceed();表示调用目标方法，如果不写此句，则目标方法不会被调用。如下所示：

 1 package com.hex.second;
 2 
 3 import org.aopalliance.intercept.methodinterceptor;
 4 import org.aopalliance.intercept.methodinvocation;
 5 
 6 /**
 7  * 环绕通知
 8  * 环绕通知的本质上是一个拦截器
 9  * @author administrator
10  *
11  */
12 public class logaround implements methodinterceptor {
13 
14     /**
15      * 
16      */
17     @override
18     public object invoke(methodinvocation invocation) throws throwable {
19         object obj = null;
20         try {
21 
22             // 前置通知
23             system.out.println("环绕实现前置通知。。。");
24             system.out.println("环绕通知：target="+invocation.getthis()+",method="+invocation.getmethod().getname()+",args="+invocation.getarguments().length);
25             // 控制目标方法的执行 obj表示目标方法的返回值，表示执行addstudent(student)方法
26             //此方法控制目标方法的执行，如果不写此方法，则目标方法不会执行，此方法前的是前置通知，此方法后的是后置通知
27             obj = invocation.proceed();
28             // 后置通知
29             system.out.println("环绕实现后置通知。。。");
30         } catch (exception e) {
31             // 异常通知
32             system.out.println("环绕实现异常通知。。。");
33             throw e;
34         }
35         // todo auto-generated method stub
36         return obj;
37     }
38 
39 }

2. 配置bean

1 <!-- 服务类 -->
2 <bean id="studentservice" class="com.hex.second.studentserviceimpl"></bean>
3 <bean id="logaround" class="com.hex.second.logaround"</bean>

3. 配置aop

所有配置切入点通知的方式都是一样的。如下所示：

1 <aop:config>
2      <aop:pointcut expression="execution(public void com.hex.second.studentserviceimpl.addstudent(com.hex.second.student))" id="pc2"/>
3      <aop:advisor advice-ref="logaround" pointcut-ref="pc2"/>
4 </aop:config>

所有的调用方式是一致的，不需要调用通知类，系统会自动调用，如下所示：

 1 package com.hex.second;
 2 
 3 import org.springframework.context.applicationcontext;
 4 import org.springframework.context.support.classpathxmlapplicationcontext;
 5 
 6 public class testmain {
 7 
 8     public static void main(string[] args) {
 9         // todo auto-generated method stub
10         //通过spring进行注入，spring上下文对象
11         applicationcontext context=new classpathxmlapplicationcontext("applicationcontext.xml");
12         istudentservice studentservice=(istudentservice)context.getbean("studentservice");
13         student student =new student();
14         studentservice.addstudent(student);
15         //studentservice.deletestudent(1);
16         //studentservice.updatestudent(0);
17     }
18 
19 }

 

备注

合抱之木，生于毫末;九层之台，起于累土;千里之行，始于足下。