一起学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接口 代码如下：

 package com.hex.second;

 /**
  * 学生服务接口
  * @author Administrator
  *
  */
 public interface IStudentService {

     /**
      * 新增学生
      * @param student
      */
     void addStudent(Student student);
     /**
      * 删除学生
      * @param id
      */
     void deleteStudent(int id);

     /**
      * 修改学生
      * @param id
      */
     void updateStudent(int id);
 }

StudentServiceImpl类 代码如下：

 package com.hex.second;

 /**
  * 学生服务事项类
  * @author Administrator
  *
  */
 public class StudentServiceImpl implements IStudentService {

     /**
      * 新增学生
      */
     public void addStudent(Student student) {
         // TODO Auto-generated method stub
         System.out.println("新增加学生。。。");
     }

     /**
      * 删除学生
      */
     @Override
     public void deleteStudent(int id) {
         // TODO Auto-generated method stub
         System.out.println("删除学生。。。");
     }

     /**
      * 修改学生
      */
     public void updateStudent(int id) {
         // TODO Auto-generated method stub
         System.out.println("修改学生");
         int i=1/0;
     }
 }

前置通知

1. 实现接口

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

Method method 表示执行的目标方法

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

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

 package com.hex.second;

 import java.lang.reflect.Method;

 import org.springframework.aop.MethodBeforeAdvice;

 public class LogBefore implements MethodBeforeAdvice {

     /***
      * 前置通知
      * method:表示调用的方法，即切入点
      * args:表示调用方法的参数
      * target：表示方法所在的目标对象
      */
     @Override
     public void before(Method method, Object[] args, Object target) throws Throwable {
         // TODO Auto-generated method stub
         System.out.println("前置通知。。。");
         System.out.println("method="+method+",args数量="+args.length+",target="+target);
     }
 }

2. 配置applicationContext.xml文件

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

 <?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:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd">

3. 配置两个类对应的bean

 <!-- 服务类 -->
 <bean id="studentService" class="com.hex.second.StudentServiceImpl"></bean>
 <!-- 前置通知类 -->
 <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】方法中的 如下所示：

 package com.hex.second;

 import java.lang.reflect.Method;

 import org.springframework.aop.AfterReturningAdvice;

 /**
  * 通过实现接口将普通类变成后置通知
  * @author Administrator
  *
  */
 public class LogAfter implements AfterReturningAdvice {

     /**
      * 后置通知实现类
      * returnValue：返回值
      * method:表示调用的方法，即切入点
      * args:表示调用方法的参数
      * target：表示方法所在的目标对象
      */
     @Override
     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
         // TODO Auto-generated method stub
         System.out.println("后置通知。。。");
         System.out.println("returnValue="+returnValue+",method="+method+",args数量="+args.length+",target="+target);
     }

 }

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

 <bean id="studentService" class="com.hex.second.StudentServiceImpl"></bean>
 <bean id="logAfter" class="com.hex.second.LogAfter"></bean>

3. AOP配置

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

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

 <!-- 将addStudent和通知进行关联 -->
 <aop:config>
      <!-- 每一个config只有一个poingcut，如果有多个，则需要配置多个config -->
      <!-- 配置切入点  id自定义，expression表示切入点的函数名-->
      <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"/>
      <!-- 配置通知 -->
      <aop:advisor advice-ref="logBefore" pointcut-ref="pc"/>

      <aop:advisor advice-ref="logAfter" pointcut-ref="pc"/>
 </aop:config>

异常通知

1. 实现接口

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

必须以固定格式实现方法：public void afterThrowing([Method, args, target], ThrowableSubclass);

 package com.hex.second;

 import java.lang.reflect.Method;

 import org.springframework.aop.ThrowsAdvice;

 /**
  * 异常通知
  * @author Administrator
  *
  */
 public class LogException implements ThrowsAdvice {

     /**
      * 异常通知执行
      * @param method 切入点
      * @param args 参数个数
      * @param target 调用目标对象
      * @param ex 异常
      */
     public void afterThrowing(Method method, Object[] args, Object target, Exception ex){
         System.out.println("异常通知。。。");
         System.out.println("method="+method+",args数量="+args.length+",target="+target+",ex="+ex);
     }
 }

2. 配置Bean类

 <!-- 服务类 -->
 <bean id="studentService" class="com.hex.second.StudentServiceImpl"></bean>
 <bean id="logException" class="com.hex.second.LogException"></bean>

3. 配置AOP

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

 <!-- 可以配置aop:config -->
 <aop:config>
         <aop:pointcut expression="execution(public void com.hex.second.StudentServiceImpl.updateStudent(int))" id="pc1"/>
      <!-- 配置通知 -->
      <aop:advisor advice-ref="logException" pointcut-ref="pc1"/>
 </aop:config>

环绕通知

1. 实现接口

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

 package com.hex.second;

 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;

 /**
  * 环绕通知
  * 环绕通知的本质上是一个拦截器
  * @author Administrator
  *
  */
 public class LogAround implements MethodInterceptor {

     /**
      *
      */
     @Override
     public Object invoke(MethodInvocation invocation) throws Throwable {
         Object obj = null;
         try {

             // 前置通知
             System.out.println("环绕实现前置通知。。。");
             System.out.println("环绕通知：target="+invocation.getThis()+",method="+invocation.getMethod().getName()+",args="+invocation.getArguments().length);
             // 控制目标方法的执行 obj表示目标方法的返回值，表示执行addStudent(student)方法
             //此方法控制目标方法的执行，如果不写此方法，则目标方法不会执行，此方法前的是前置通知，此方法后的是后置通知
             obj = invocation.proceed();
             // 后置通知
             System.out.println("环绕实现后置通知。。。");
         } catch (Exception e) {
             // 异常通知
             System.out.println("环绕实现异常通知。。。");
             throw e;
         }
         // TODO Auto-generated method stub
         return obj;
     }

 }

2. 配置Bean

 <!-- 服务类 -->
 <bean id="studentService" class="com.hex.second.StudentServiceImpl"></bean>
 <bean id="logAround" class="com.hex.second.LogAround"</bean>

3. 配置AOP

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

 <aop:config>
      <aop:pointcut expression="execution(public void com.hex.second.StudentServiceImpl.addStudent(com.hex.second.Student))" id="pc2"/>
      <aop:advisor advice-ref="logAround" pointcut-ref="pc2"/>
 </aop:config>

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

 package com.hex.second;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class TestMain {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         //通过Spring进行注入，Spring上下文对象
         ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
         IStudentService studentService=(IStudentService)context.getBean("studentService");
         Student student =new Student();
         studentService.addStudent(student);
         //studentService.deleteStudent(1);
         //studentService.updateStudent(0);
     }

 }

备注

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