注解方式实现AOP

下面主要描述spring中使用AOP的两个例子：一个采用注解的方式来实现，另一个采用声
明的方式来实现。描述这两个例子有两个目的：一是熟悉spring中的AOP使用，二就是以这些
例子作为以后对spring AOP分析作铺垫。废话少说，首先复兴下AOP种一些比较重要的概念：

    Joinpoint（连接点）：程序执行时的某个特定的点，在Spring中就是某一个方法的执行
    Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法
是需要被增强、被代理的。一般都是按照一定的约定规则来表示的，如正则表达式等。切点是
由一类连接点组成。
    Advice（通知)：还是说的通俗点，就是在指定切点上要干些什么。
    Advisor（通知器)：其实就是切点和通知的结合

    好了，概念就不多说了，如果要了解详细点，可以google一把，现在先描述出两个例子中
的一个，其中一个是采用注解的方式来实行切面编程，具体如下：

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

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,在该通知类里，通过注入的形式来定义切面、通知以及通知所左右的切点，具体如下：

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的配置文件中作如下配置：

Java代码

<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,具体如下：

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，个
                    连接点类型可以调用代理的方法，并获取、改变返回值。

猜你喜欢