Spring AOP笔记

最近研究了下spring的aop，从spring2开始，spring支持基于XML和annotation的两种配置，先来看看基于XML配置的实现。

 

基于XML配置的实现：

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

    <bean id="log" class="com.inter.GetLog"></bean>

    <!--
        注意这里：expression="execution(* com.inter.*.print*(..))"
        括号里面第一个*号代表返回值 接下来  com.inter.*. 是你要切入的代码的大概路径，这里为什么用大概路径来形容呢
        因为这里的意思是符合以com.inter的路径都会作为选择的对象，也不详细介绍，查下就明白了， print*(..)是指
        方法名以print开头的都符合，括号里面的 .. 表示参数是随意的都可以。
    -->
    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="printMethods" expression="execution(* com.inter.*.print*(..))"/>
            <aop:around method="getLog" pointcut-ref="printMethods"/>
        </aop:aspect>
    </aop:config>
   
    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="dealException" expression="execution(* com.inter.*.excep*(..))"/>
            <aop:around method="getLog" pointcut-ref="dealException"/>
        </aop:aspect>
    </aop:config>

 

    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="before" expression="execution(* com.inter.*.bef*(..))"/>
            <aop:before method="before" pointcut-ref="before"/>
        </aop:aspect>
    </aop:config>   

    <!--要织入代码的bean-->
    <bean id="print" class="com.inter.SystemPrint"></bean>
   
</beans>

 

SystemPrin的实现类：

public class SystemPrint implements Print{
   
    public String print(String name){
        String result="hello " + name;
        System.out.println(result);
        return result;
    }

 

    public String before(String name){
        String result="before " + name;
        System.out.println(result);
        return result;
    }   

 

    public void exception(String name) throws Exception{
        System.out.println(name);
        throw new Exception();
    }
}

 

下面是所要织入的代码，也就是我们要用来打印和处理异常：

import org.aspectj.lang.ProceedingJoinPoint;
public class GetLog {   
    public void getLog(ProceedingJoinPoint joinpoint) throws Throwable {       
        System.out.println("===begin===");
        try{
            joinpoint.proceed();
        }
        catch(Exception e)
        {
            System.out.println("log exception!");
        }
        System.out.println("===end=====");
    }

 

   public void before(JoinPoint joint) throws Throwable
    {
        System.out.println("===begin===");
        System.out.println("before!");
    }

 

}

 

编写一个测试类，分别测试上面两个方法，可以得到如下的结果：

===begin===
hello ding
===end=====
-----------------
===begin===
laoding
log exception!
===end=====
-----------------
===begin===
before!
before beforeing

 

下面来看看基于Annotation的实现：

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

    <!--基于@AspectJ切面的驱动器，如果没有这句话  切面的代码是不会执行的，可以试下-->
    <aop:aspectj-autoproxy/>

    <bean id="myAspect" class="com.inter.MyAspect"></bean>
    <bean id="hello" class="com.inter.HelloImpl"></bean>
   
</beans>

 

HelloImpl类的实现：

public class HelloImpl implements Hello {   
    public String hello(String name)
    {
        String say = "Hello," + name;

        System.out.println(say);
        return say;
    }
}

 

切面的实现：

//首先这是注释这个类就是切面
@Aspect
public class MyAspect {
    /*这里是注释要切入的方法，AfterReturning是表示方法返回以后进行切入，我这里
       选这个的话是因为日志一般都是在方法执行完成后记录，当然你可以拿Before来试*/
    @Around("execution(* com.inter.*.hello(..))")
    public void doLog(ProceedingJoinPoint joinpoint) throws Throwable{
        String result = (String)joinpoint.proceed();
        System.out.println("---doLog"+result);
    }
}

 

然后编写一个测试类，得到如下测试结果：

-----------------
Hello,xiao
---doLogHello,xiao