前面说到Spring的AOP，今天继续说说AOP中的配置切面的两种方式。
一、用AspectJ注解声明切面
1、AspectJ简介
AspectJ：Java社区里最完整最流行的AOP框架。
在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。
2、在Spring中启用AspectJ注解支持
- 导入JAR包
①com.springsource.net.sf.cglib-2.2.0.jar
②com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
③spring-aop-4.0.0.RELEASE.jar
④spring-aspects-4.0.0.RELEASE.jar
- 引入aop名称空间
3) 配置
<aop:aspectj-autoproxy>
当Spring IOC容器侦测到bean配置文件中的<aop:aspectj-autoproxy>元素时，会自动为 与AspectJ切面匹配的bean创建代理：
aspectAnnotation.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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
<context:component-scan base-package="com.spring.aspect"></context:component-scan>
<aop:aspectj-autoproxy />
</beans>
接下来编写一个加减乘除的接口以及实现类用于测试：
Calculator 接口：
package com.spring.aspect;
public interface Calculator {
public int add(int i, int j);
public int sub(int i, int j);
public int mul(int i, int j);
public int div(int i, int j);
}
CalculatorImpl 实现类：
package com.spring.aspect;
import org.springframework.stereotype.Component;
@Component
public class CalculatorImpl implements Calculator{
@Override
public int add(int i, int j) {
System.out.println("add");
return i+j;
}
@Override
public int sub(int i, int j) {
System.out.println("sub");
return i-j;
}
@Override
public int mul(int i, int j) {
System.out.println("mul");
return i*j;
}
@Override
public int div(int i, int j) {
System.out.println("div");
return i/j;
}
}
4、在用注解配置切面的注意事项：
- 要在Spring中声明AspectJ切面，只需要在IOC容器中将切面声明为bean实例。
- 当在Spring IOC容器中初始化AspectJ切面之后，Spring IOC容器就会为那些与 AspectJ切面相匹配的bean创建代理。
- 在AspectJ注解中，切面只是一个带有@Aspect注解的Java类，它往往要包含很多通知。 通知是标注有某种注解的简单的Java方法。共有以下几种类型：
① @Before：前置通知，在方法执行之前执行
② @After：后置通知，在方法执行之后执行
③ @AfterRunning：返回通知，在方法返回结果之后执行
④ @AfterThrowing：异常通知，在方法抛出异常之后执行
⑥ @Around：环绕通知，围绕着方法执行
了解完配置切面后开始测试：
使用注解配置CalculatorLoggingAspect 类：
package com.spring.aspect;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Component
@Aspect
public class CalculatorLoggingAspect {
public void pointCut() {}
//横切关注点
/**
*1、 前置通知
* execution切入点表达式
* JoinPoint 连接点 包含了切入点表达式所指向的具体方法信息。
* @param jp
*/
@Before(value="execution(* *.*(..))")
public void logBefore(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println("before:"+jp.getSignature().getName()
+ Arrays.toString(args));
}
/**
* 2、后置通知
* @param jp
*/
@After(value="execution(public int com.spring.aspect.CalculatorImpl.add(int,int))")
public void logAfter(JoinPoint jp) {
System.out.println("后置通知。。。。");
}
/**
* 3、返回通知
* @param jp
* @param result
*/
@AfterReturning(value="execution(* *.*(..))",returning="result")
public void logAfterReturn(JoinPoint jp, int result) {
Object[] args = jp.getArgs();
String name = jp.getSignature().getName();
System.out.println("afterReturn:"+result);
}
/**
* 4、异常通知
* @param jp
* @param e
*/
@AfterThrowing(value="execution(* com.spring.aspect.CalculatorImpl.div(int,int))",throwing="e")
public void logAfterThrow(JoinPoint jp,RuntimeException e) {
System.out.println("logAfterThrow:"+e);
}
/**
* 5、环绕通知
* @param pjp
* @return
*/
@Around("execution(* *.*(..))")
public Object logAround(ProceedingJoinPoint pjp) {
Object[] args = pjp.getArgs();
String name = pjp.getSignature().getName();
Object result = null;
try {
System.out.println(name+",参数"+Arrays.toString(args));//前置
result = pjp.proceed(); //调用目标方法
System.out.println(name+"返回值："+result);//后置返回
} catch (Throwable e) { //异常
e.printStackTrace();
}
return result; //最终通知
}
}
测试类：
package com.spring.aspect;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("aspectAnnotation.xml");
Calculator cal = ctx.getBean(Calculator.class);
cal.add(10, 5);
System.out.println("-------------------");
cal.div(10, 5);
}
}
测试结果：
二、使用XML配置切面
除了使用AspectJ注解声明切面，Spring也支持在bean配置文件中声明切面。这种声明是通过aop名称空间中的XML元素完成的。
说一说配置的细节
1、在bean配置文件中，所有的Spring AOP配置都必须定义在<aop:config>元素内部。
对于每个切面而言，都要创建一个<aop:aspect>元素来为具体的切面实现引用后端bean实例。
切面bean必须有一个标识符，供<aop:aspect>元素引用。
2、声明切入点
- 切入点使用<aop:pointcut>元素声明。
- 切入点必须定义在<aop:aspect>元素下，或者直接定义在<aop:config>元素下。
① 定义在<aop:aspect>元素下：只对当前切面有效
② 定义在<aop:config>元素下：对所有切面都有效 - 基于XML的AOP配置不允许在切入点表达式中用名称引用其他切入点。
3、声明通知
- 在aop名称空间中，每种通知类型都对应一个特定的XML元素。
- 通知元素需要使用<pointcut-ref>来引用切入点，或用<pointcut>直接嵌入切入点表达式。
- method属性指定切面类中通知方法的名称。
接下来就来配置一个切面：
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
<bean id="cal" class="com.spring.aspect.CalculatorImpl"></bean>
<bean id="logAspect" class="com.spring.aspect.CalculatorLoggingAspect"></bean>
<!-- 配置形式 -->
<aop:config>
<!-- pointcut切入点表达式 -->
<aop:pointcut expression="execution(* *.*(..))" id="cut"/>
<!-- aspect 标签切面 -->
<aop:aspect ref="logAspect" order="0">
<!-- method:指定切面类中通知方法的名称 -->
<aop:before method="logBefore" pointcut-ref="cut"/>
<aop:after method="logAfter" pointcut-ref="cut" />
<aop:after-returning method="logAfterReturn" returning="result" pointcut-ref="cut"/>
<aop:after-throwing method="logAfterThrow" throwing="e" pointcut-ref="cut"/>
</aop:aspect>
<aop:aspect order="1">
</aop:aspect>
</aop:config>
</beans>
那我们修改一下CalculatorLoggingAspect 类使用XML来配置切面：
CalculatorLoggingXML 类：
package com.spring.aspect;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component
public class CalculatorLoggingXML {
public void pointCut() {}
//横切关注点
//写方法(通知)
/**
* 前置通知
* execution切入点表达式
* JoinPoint 连接点 包含了切入点表达式所指向的具体方法信息。
* @param jp
*/
public void logBefore(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println("before:"+jp.getSignature().getName()
+ Arrays.toString(args));
}
/**
* 后置通知
*
* @param jp
*/
public void logAfter(JoinPoint jp) {
System.out.println("后置通知。。。。");
}
/**
* 返回通知
* @param jp
* @param result
*/
public void logAfterReturn(JoinPoint jp, int result) {
Object[] args = jp.getArgs();
String name = jp.getSignature().getName();
System.out.println("afterReturn:"+result);
}
/**
* 异常通知
* @param jp
* @param e
*/
public void logAfterThrow(JoinPoint jp,RuntimeException e) {
System.out.println("logAfterThrow:"+e);
}
/**
* 环绕通知
* @param pjp
* @return
*/
public Object logAround(ProceedingJoinPoint pjp) {
Object[] args = pjp.getArgs();
String name = pjp.getSignature().getName();
Object result = null;
try {
System.out.println(name+",参数"+Arrays.toString(args));//前置
result = pjp.proceed(); //调用目标方法
System.out.println(name+"返回值："+result);//后置返回
} catch (Throwable e) { //异常
e.printStackTrace();
}
return result; //最终通知
}
}
相比较注解而言可以发现通知，也就是方法名上的注解全都不见了，去哪里了呢？
可以发现通知都在XML配置了，那继续测试一下看是否配置成功。
测试类：
package com.spring.aspect;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("aspectXml.xml");
Calculator cal = ctx.getBean(Calculator.class);
cal.add(10, 5);
System.out.println("-------------------");
cal.div(10, 5);
}
}
测试结果：
可以发现与用注解配置的切面结果都正常显示，也就是两者皆可行。
那么对于这两种方式有什么优缺点？什么情况用到？
在正常情况下，基于注解的声明要优先于基于XML的声明。通过AspectJ注解，切面可以与AspectJ兼容，而基于XML的配置则是Spring专有的。由于AspectJ得到越来越多的 AOP框架支持，所以以注解风格编写的切面将会有更多重用的机会。
扫一扫
798
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
