注解和声明方式实现AOP

下面主要描述spring中使用AOP的两个例子：一个采用注解的方式来实现，另一个采用声明的方式来实现。描述这两个例子有两个目的：一是熟悉spring中的AOP使用，二就是以这些例子作为以后对spring AOP分析作铺垫。废话少说，首先复兴下AOP种一些比较重要的概念： 
   Joinpoint（连接点）：程序执行时的某个特定的点，在Spring中就是某一个方法的执行 
   Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法是需要被增强、被代理的。一般都是按照一定的约定规则来表示的，如正则表达式等。切点是由一类连接点组成。
    Advice（通知)：还是说的通俗点，就是在指定切点上要干些什么。
    Advisor（通知器)：其实就是切点和通知的结合 
    

一、注解方式实现AOP
   以下是采用注解的方式来实行切面编程，具体如下： 
    首先，在spring配置文件中加入如下配置（用来申明spring对@AspectJ的支持）：
    <aop:aspectj-autoproxy/> 如果你使用的是DTD，可以在Spring配置文件中加入如下配置来申明spring对@Aspect的支持： 
   <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />编写目标对象类（CommonEmployee.java），具体代码如下（省略接口类)：

package com.aop;   
  
public class CommonEmployee implements Employee{   
 
    private String name;        
    public String getName() {   
        return name;   
    }     
    public void setName(String name) {   
       this.name = name;   
   }         
    public void signIn() {   
       System.out.println(name+"已经签到了...........");   
   }   
}

  然后编写通知类AspectJLogger.java,在该通知类里，通过注入的形式来定义切面、通知以及通知所左右的切点，具体如下：

package com.aop;   
  
import java.util.Date;   
  
import org.aspectj.lang.ProceedingJoinPoint;   
import org.aspectj.lang.annotation.After;   
import org.aspectj.lang.annotation.Around;   
import org.aspectj.lang.annotation.Aspect;   
import org.aspectj.lang.annotation.Before;   
  
/**  
 * 使用@Aspect 注解的类， Spring 将会把它当作一个特殊的Bean（一个切面），也就是  
 * 不对这个类本身进行动态代理  
 */  
@Aspect     
public class AspectJLogger {   
   /**  
    * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的  
    */  
   public static final String EDP = "execution(* com.aop.CommonEmployee.sign*(..))";   
       
   @Before(EDP)    //spring中Before通知   
    public void logBefore() {   
       System.out.println("logBefore:现在时间是:"+new Date());   
    }   
       
   @After(EDP)    //spring中After通知   
    public void logAfter() {   
       System.out.println("logAfter:现在时间是:"+new Date());   
    }   
       
   @Around(EDP)   //spring中Around通知   
    public Object logAround(ProceedingJoinPoint joinPoint) {   
       System.out.println("logAround开始:现在时间是:"+new Date()); //方法执行前的代理处理   
        Object[] args = joinPoint.getArgs();   
       Object obj = null;   
       try {   
           obj = joinPoint.proceed(args);   
       } catch (Throwable e) {   
           e.printStackTrace();   
       }   
       System.out.println("logAround结束:现在时间是:"+new Date());  //方法执行后的代理处理   
        return obj;   
    }   
}  

然后，在Spring的配置文件中作如下配置：

<aop:aspectj-autoproxy/>    
<bean id="aspect" class="com.aop.AspectJLogger" />   
<bean id="employee" class="com.aop.CommonEmployee">   
  <property name="name" value="good"></property>   
</bean> 

编写测试类Test.java,具体如下：

package com;   
  
import org.springframework.context.ApplicationContext;   
import org.springframework.context.support.ClassPathXmlApplicationContext;   
  
import com.aop.Employee;   
  
public class Test {   
    public static void main(String[] args) throws Exception{   
        ApplicationContext act = new ClassPathXmlApplicationContext("applicationContext-aop.xml");   
        Employee e = (Employee)act.getBean("employee");   
        e.signIn();             
    }   
}

测试得出结果为：logBefore:现在时间是:Thu Apr 01 16:34:27 CST 2010
                               logAround开始:现在时间是:Thu Apr 01 16:34:27 CST 2010 
                               good已经签到了...........
                               logAfter:现在时间是:Thu Apr 01 16:34:27 CST 2010
                              logAround结束:现在时间是:Thu Apr 01 16:34:27 CST 2010
一些注意的知识： 
1.环绕方法通知，环绕方法通知要注意必须给出调用之后的返回值，否则被代理的方法会停止调用并返回null，除非你真的打算这么做。
2.只有环绕通知才可以使用JoinPoint的子类ProceedingJoinPoint，个 连接点类型可以调用代理的方法，并获取、改变返回值。

 

二、声明方式实现AOP

   CommonEmployee.java和注解AOP中的类一样，没有变化，也就是说目标对象是不变的,，通知类发生了一点小改变，具体通知类Logger.java如下：

package com.aop;   
  
import java.util.Date;   
import org.aspectj.lang.ProceedingJoinPoint;   
  
public class Logger{   
  
    //spring中Before通知   
    public void logBefore() {   
        System.out.println("logBefore:现在时间是:"+new Date());   
    }   
       
    //spring中After通知   
    public void logAfter() {   
        System.out.println("logAfter:现在时间是:"+new Date());   
    }   
       
    //spring中Around通知   
    public Object logAround(ProceedingJoinPoint joinPoint) {   
        System.out.println("logAround开始:现在时间是:"+new Date()); //方法执行前的代理处理   
        Object[] args = joinPoint.getArgs();   
        Object obj = null;   
        try {   
            obj = joinPoint.proceed(args);   
        } catch (Throwable e) {   
            e.printStackTrace();   
        }   
        System.out.println("logAround结束:现在时间是:"+new Date());  //方法执行后的代理处理   
        return obj;   
    }        
} 

可以看见，上面的通知类没有引入注解了。所以，要想在spring中使用没有注解的通知类，则必须在spring配置文件中作如下配置：

<span style="font-size:14px;"><bean id="employee" class="com.aop.CommonEmployee">   
    <property name="name" value="good"></property>   
    </bean>   
    <bean id="advice" class="com.aop.Logger" />   
    <aop:config >   
      <aop:aspect ref="advice">   
        <aop:pointcut id="pointcut" expression="execution(* com.aop.CommonEmployee.sign*(..))"/>   
        <aop:before method="logBefore" pointcut-ref="pointcut"/>   
        <aop:after method="logAfter" pointcut-ref="pointcut"/>   
        <aop:around method="logAround" pointcut-ref="pointcut"/>   
      </aop:aspect>   
    </aop:config>
</bean></span>

最后，测试类Test.java代码同上

最后得出测试结果如下：
  logBefore:现在时间是:Fri Apr 02 14:44:37 CST 2010
  logAround开始:现在时间是:Fri Apr 02 14:44:37 CST 2010
  good已经签到了...........
  logAfter:现在时间是:Fri Apr 02 14:44:37 CST 2010
  logAround结束:现在时间是:Fri Apr 02 14:44:37 CST 2010