Spring AOP——基于XML的进阶案例

我们需要先引入jar包依赖（Maven项目）：

 <dependencies> 

   <dependency>

        <groupId>org.springframework</groupId>  

      <artifactId>spring-context</artifactId>    

    <version>4.3.9.RELEASE</version> 

   </dependency>     

   <!-- spring底层AOP的实现,需要依赖于AspectJ框架（不要引入1.8.5版本，会有版本冲突问题） -->   

<dependency> 

<groupId>org.aspectj</groupId> 

<artifactId>aspectjrt</artifactId> 

<version>1.8.9</version>  

  </dependency> 

   <dependency> 

<groupId>org.aspectj</groupId> 

<artifactId>aspectjweaver</artifactId>

 <version>1.8.9</version>   

</dependency>   

  <!-- 引入单元测试 -->  

  <dependency>  

      <groupId>junit</groupId>     

   <artifactId>junit</artifactId>     

   <version>4.7</version> 

   </dependency> 

</dependencies>

    编写业务接口和实现类：

1.  
   package com.test.service;
2.  
    
3.  
   /**
4.  
    * 核心业务接口
5.  
    * @author Elio
6.  
    */
7.  
   public interface HelloService {
8.  
   void sayHello(String msg);
9.  
   void sayBye(String msg);
10.  
    }

    package com.test.service;

    import org.springframework.stereotype.Service;

    /**

    * 核心业务实现 *

    @author Elio

    */

    @Service

    public class HelloServiceImpl implements HelloService {

     public void sayHello(String msg) { 

     System.out.println("hello "+msg);

     } 

    public void sayBye(String msg) {  

    System.out.println("bye "+msg);

     }

    }

    编写一个高级切面：

    public class AdvencedAspect {

      /**   * 前置通知，希望此方法在核心业务方法执行之前执行   */ 

    public void beforeMethod() { 

      System.out.println("before"); 

    } 

    /**   * 后置通知，希望此方法在核心业务方法执行之后执行   */ 

    public void afterMethod() {  

    System.out.println("after"); 

    } 

    /**   * 返回通知，希望此方法在核心业务方法返回结果之后执行   */ 

    public void returnMethod() { 

      System.out.println("returned"); 

    }

      /**   * 异常通知，希望此方法在核心业务方法抛出异常之后执行   */ 

    public void thrownMethod() {  

    System.out.println("thrown"); 

    } 

    /**   * 环绕通知   * @param joinPoint 连接点对象，由Spring自行创建并注入   */ 

    public void aroundMethod(ProceedingJoinPoint joinPoint) { 

      System.out.println("around begin");   try {   joinPoint.proceed();  

    } catch (Throwable e) { 

      e.printStackTrace();  

    }  

    System.out.println("around stop");

      }

    }

        在XML配置文件中完成配置：

    <!-- 开启扫描包创建实例 -->

     <context:component-scan base-package="com.test.service"/> 

    <!-- 创建用于执行扩展业务的实例  -->

     <bean id="advencedAspect" class="com.test.aspect.AdvencedAspect" />

     <!-- 配置AOP方案 --> <aop:config> 

     <!-- Spring AOP支持方法级别的精细切入点，且支持通配符 -->  

    <aop:pointcut expression="execution(* com.test.service.HelloServiceImpl.say*(..))"   id="helloPt"/> 

     <!-- 定义一个或多个切面,这里要注意切点的定义要在切面之前 -->

      <aop:aspect ref="advencedAspect">  

     <!-- 定义前置通知(切入点指向的业务方法之前执行，如果抛出异常则不执行核心业务方法) --> 

      <aop:before method="beforeMethod" pointcut-ref="helloPt" /> 

      <!-- 定义返回通知(切入点指向的业务方法返回结果之后执行，如果前置通知或核心业务抛出异常则不执行) --> 

      <aop:after-returning method="returnMethod" pointcut-ref="helloPt" /> 

      <!-- 定义异常通知(切入点指向的业务方法抛出异常之后执行) -->  

     <aop:after-throwing method="thrownMethod" pointcut-ref="helloPt"/> 

      <!-- 定义后置通知 (切入点指向的业务方法之后,无论是否抛出异常都会执行) -->  

     <aop:after method="afterMethod" pointcut-ref="helloPt" /> 

      <!-- 定义环绕通知，参数由Spring容器自行创建并传递 --> 

      <aop:around method="aroundMethod" pointcut-ref="helloPt"/> 

     </aop:aspect> </aop:config>

     

        编写测试类的测试方法：

      /**  * 测试具体业务应用  */

     @Test

     public void testSayHello(){  

    //1.获取对象 

     HelloService hService=ctx.getBean("helloServiceImpl",HelloService.class);  

    //2.执行业务  

    hService.sayHello("handsome boy"); 

    }