Spring AOP的解读

一、为什么会有AOP

在日常的开发中经常会有这样一种场景,支付相关的业务中经常需要记录日志,而记录的日志大体相同;这样就会造成支付组件和日志组件强关联,耦合在一起了。而AOP的出现就是为了解决这种问题的。

二、什么是AOP

AOP里面有这样几个概念:目标对象、切点、切面支持类、切面、通知。AOP为开发者提供一种横切关注点(如日志组件横切了支付组件)分离并织入的机制,把横切关注点分离,然后通过某种技术织入到系统中,从而解耦了相关组件。

三、认识AOP

 使用AOP功能需要的jar包如下:

 

1、接口类:

public interface IHelloWorldService
{
    public boolean sayHello();
}

2、接口实现类:

public class HelloWorldService implements IHelloWorldService
{
    public boolean sayHello()
    {
        System.out.println("=======Hello World:");    
        return true;
    }
}

3、切面支持类:该类就是通知的具体实现,切面是切点+通知的组合。

public class HelloWorldAspect
{
    public void beforeAdvice()
    {
        System.out.println("=======before advice:");
    }
    
    public void afterFinalAdvice()
    {
        System.out.println("========after advice" );
    }
}
HelloWorldAspect并不是真正的切面实现,而是定义通知实现的类,我们可以将它看做是缺少了切入点的切面。

4、Spring配置文件

<bean id="helloWorldService" class="aop.HelloWorldService"/>
   
   <bean id="aspect" class="aop.HelloWorldAspect"/>
   <aop:config>
   <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>
           <aop:aspect ref="aspect">
               <aop:before pointcut-ref="pointcut" method="beforeAdvice()"/>
               <aop:after pointcut="execution(* aop..*.*(..))" method="afterFinalAdvice"/>
           </aop:aspect>
   </aop:config>

1、<aop:config>:AOP相关的功能都在该标签下面

2、<aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>

切点的定义,这种定义的方式可以让多个切面通过id的形式重复引用,expression表达式表示的是匹配aop包(包含子包)下任何类的任何方法。

3、<aop:aspect ref="aspect">

标签<aop:aspect>用来定义切面,其中的ref用来引用切面支持类的方法。

4、<aop:before pointcut-ref="pointcut" method="beforeAdvice()"/>

这里定义的是前置通知,包含切点和通知里面的具体方法。其中定义切点有两种方式:pointcut-ref="pointcut"或者pointcut="execution(* aop..*.*(..))",两者只能选择其一。而method用来引用切面通知实现类中的方法。

5、测试类:

public class AopTest
{
    public static void main(String[] args) throws Exception
    {
        ApplicationContext ctx =
            new ClassPathXmlApplicationContext("applicationContext.xml");
        IHelloWorldService bean =
           ctx.getBean("helloWorldService",IHelloWorldService.class);
        bean.sayHello();
    }
}

6、执行结果:

=======before advice:
=======Hello World:
========after advice

从结果可以看出来,尽管DEMO很简单,但是实现了关联组件的解耦。可以通过定义切面的方式,让目标方法在执行前后,执行我们的通知方法。

四、Spring的通知类型

在前面的实例中,用到了前置通知和后置最终通知两种类型。在现实情况中,组件组合的方式不仅要有很多种,而且还要很灵活。这就要求Spring对切面有不同形式的定义,所以Spring给我们带来了如下几种通知:

1、前置通知:在切入点选择的连接点处的方法执行之前的通知,该通知不影响正常程序的执行流程。

2、后置最终通知:在切入点选择的连接点处的方法返回时执行的通知,不管业务方法是否抛出异常,都会调用该通知,相当于finally块。

3、后置返回通知:在切入点选择的连接点处的方法正常执行完毕时执行的通知(连接点处方法执行完毕后没有抛出任何异常才会去执行该通知)

4、后置异常通知:在切入点选择的连接点处的方法抛出异常返回时执行的通知。(连接点处的方法抛异常才会执行该通知)

5、环绕通知:环绕着在切入点选择的连接点处的方法所执行的通知,环绕通知可以在方法调用之前和之后自定义任何行为,并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。

我们现在看来下这几种通知的具体实现:

1)前置通知

这次演示前置通知如何传递参数:

目标类:

public class HelloWorldService implements IHelloWorldService
{
    public boolean sayHello(String str)
    {
        System.out.println("=======Hello World: str=" + str);    
        return true;
    }
}

切面支持类:

public class HelloWorldAspect
{
    public void beforeAdvice(String str)
    {
        System.out.println("=======before advice: str=" +  str);
    }
    
    public void afterFinalAdvice()
    {
        System.out.println("========after advice" );
    }
}

切面定义:

<bean id="helloWorldService" class="aop.HelloWorldService"/>
   <bean id="aspect" class="aop.HelloWorldAspect"/>
   <aop:config>
   <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..)) and args(param)"/>
           <aop:aspect ref="aspect">
               <aop:before pointcut-ref="pointcut" method="beforeAdvice(java.lang.String)" arg-names="param"/>
           </aop:aspect>
   </aop:config>

切面的配置最关键,这里的切点的表达式定义在原有的基础上新增了一个参数,参数的类型与通知实现方式中的类型相同。

而前置通知里面方法的类型为String,arg-names="param"的作用是切入点中使用“args(param)”匹配的目标方法参数将自动传递给通知实现方法同名参数。

测试类:

public class AopTest
{
    public static void main(String[] args) throws Exception
    {
        ApplicationContext ctx =
            new ClassPathXmlApplicationContext("applicationContext.xml");
        IHelloWorldService bean =
           ctx.getBean("helloWorldService",IHelloWorldService.class);
        bean.sayHello("hangzhou");
    }
}

执行结果:

=======before advice: str=hangzhou
=======Hello World: str=hangzhou

 2)后置返回通知

目标类:目标方法返回值为true

public class HelloWorldService implements IHelloWorldService
{
    public boolean sayHello()
    {
        System.out.println("=======Hello World");    
        return true;
    }
}

通知实现类,这里接收

public class HelloWorldAspect
{
    public void beforeAdvice(String str)
    {
        System.out.println("=======before advice: str=" +  str);
    }
    
    public void afterFinalAdvice(Object arg)
    {
        System.out.println("========after advice.arg=" + arg);
    }
}

切面配置:其中arg-names="retVal"表示指定通知方法的参数名为“retVal”;returning="retVal"用于将目标方法的返回值赋给通知实现方法中参数名为“retVal”的参数

 <bean id="helloWorldService" class="aop.HelloWorldService"/>
   <bean id="aspect" class="aop.HelloWorldAspect"/>
   <aop:config>
   <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>
           <aop:aspect ref="aspect">
               <aop:after-returning pointcut-ref="pointcut" 
                  method="afterFinalAdvice" arg-names="retVal" returning="retVal"/>
           </aop:aspect>
   </aop:config>

执行结果:

=======Hello World
========after advice.arg=true

这里可以看到目标方法的返回值赋给了通知实现方法中的参数。

3)后置异常通知

目标类:

public class HelloWorldService implements IHelloWorldService
{
    public boolean sayHello()
    {
        System.out.println("=======Hello World");    
        throw new RuntimeException();
    }
}

通知实现类:

public class HelloWorldAspect
{
    public void beforeAdvice(String str)
    {
        System.out.println("=======before advice: str=" +  str);
    }
    
    public void afterFinalAdvice(Exception arg)
    {
        System.out.println("========after advice.arg=" + arg );
    }
}

切面定义部分:这里与参数传递类似,目标类抛出异常,通知方法才会被执行。且这里通过参数传递的方式,实现了将目标方法抛出的异常作为参数传递到通知实现方法中

<aop:config>
   <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>
           <aop:aspect ref="aspect">
               <aop:after-throwing pointcut-ref="pointcut" 
                  method="afterFinalAdvice" arg-names="retVal" throwing="retVal"/>
           </aop:aspect>
   </aop:config>

执行结果:

=======Hello World
========after advice.arg=java.lang.RuntimeException

 4)环绕通知:环绕通知时十分强大,可以决定目标方法是否执行、什么时候执行、执行时是否需要替换方法参数、执行完毕后是否需要替换返回参数。

环绕通知方法中的第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型,在通知实现方法内部使用ProceedingJoinPoint的proceed()方法使目标方法执行,proceed方法可以传入可选的Object[]数组,该数组的值将作为目标方法执行时的参数。

目标类:

public class HelloWorldService implements IHelloWorldService
{
    public boolean sayHello()
    {
        System.out.println("=======Hello World");    
        throw new RuntimeException();
    }

    @Override
    public void around(String param)
    {
        System.out.println("======Hello Around param:" + param);
    }
}

通知实现类片段:

public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable
    {
        Object retVal = pjp.proceed(new Object[] {"hangzhou"});  
        System.out.println("===========around after advice"); 
        return retVal;
    }

切面定义部分:

<aop:config>
   <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>
           <aop:aspect ref="aspect">
               <aop:around pointcut-ref="pointcut" 
                  method="aroundAdvice"/>
           </aop:aspect>
   </aop:config>

测试类:

  public static void main(String[] args) throws Exception
    {
        ApplicationContext ctx =
            new ClassPathXmlApplicationContext("applicationContext.xml");
        IHelloWorldService bean =
           ctx.getBean("helloWorldService",IHelloWorldService.class);
        bean.around("haha");
    }

执行结果:

======Hello Around param:hangzhou
===========around after advice

从结果看到,我们在测试类中传入的参数“haha”被通知实现类中的方法替换成了“hangzhou”。

这里要注意的是:Object retVal = pjp.proceed(new Object[] {"hangzhou"}); ,proceed方法用于执行目标方法,且目标方法的参数被new Object[]该数组替换,最终返回retVal字段。

引入

Spring允许为目标类引入新的接口,通过在< aop:aspect>标签内使用< aop:declare-parents>标签进行引入

引入新增接口:

public interface IProductService
{
    public void product();
}

接口实现类:

public class ProductService implements IProductService
{
    @Override
    public void product()
    {
        System.out.println("==========hello product");
    }
}

配置文件:types-matching表示匹配接口IHelloWorldService的实现类,如HelloWorldService;implement-interface表示引入的接口;default-impl表示引入接口的实现。

<aop:config>
           <aop:aspect>
               <aop:declare-parents types-matching="aop.IHelloWorldService+" 
                     implement-interface="aop.IProductService" 
                      default-impl="aop.ProductService"/>
           </aop:aspect>
   </aop:config>

测试类:ctx.getBean("helloWorldService", IProductService.class);可以直接获取到引入的接口。

public static void main(String[] args) throws Exception
    {
        ApplicationContext ctx =
            new ClassPathXmlApplicationContext("applicationContext.xml");
        // IHelloWorldService bean =
        // ctx.getBean("helloWorldService",IHelloWorldService.class);
        // bean.around("haha");
        IProductService productService =
            ctx.getBean("helloWorldService", IProductService.class);
        productService.product();
    }

执行结果:

==========hello product

 

posted @ 2017-03-01 20:33  冬瓜蔡  阅读(1019)  评论(0编辑  收藏  举报