Spring AspectJ AOP框架注解原理解析

2023-07-17 10:06:04 70

什么是AspectJ

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

AspectJ是一个基于Java语言的AOP框架

Spring2.0以后新增了对AspectJ切点表达式支持

@AspectJ是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

新版本Spring框架，建议使用AspectJ方式来开发AOP

AspectJ表达式:

语法:execution(表达式)

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
execution(“cn.itcast.spring3.demo1.dao.(..)”)---只检索当前包
execution(“cn.itcast.spring3.demo1.dao..(..)”)---检索包及当前包的子包.
execution(cn.itcast.dao.GenericDAO+.(..))---检索GenericDAO及子类

AspectJ增强:

@Before前置通知，相当于BeforeAdvice
@AfterReturning后置通知，相当于AfterReturningAdvice
@Around环绕通知，相当于MethodInterceptor
@AfterThrowing抛出通知，相当于ThrowAdvice
@After最终final通知，不管是否异常，该通知都会执行
@DeclareParents引介通知，相当于IntroductionInterceptor(不要求掌握)

基于注解

第一步:引入相应jar包.

aspectj依赖aop环境.

spring-aspects-3.2.0.RELEASE.jar

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

第二步:编写被增强的类:

UserDao

packagecn.spring3.demo1;
/**
*@authorNOP
*被代理的对象
*/
publicclassUserDao{
publicvoidadd(){
//TODOAuto-generatedmethodstub
System.out.println("添加客户");
}
publicvoiddelete(){
//TODOAuto-generatedmethodstub
System.out.println("删除客户");
inti=1/0;
}
publicStringfind(){
//TODOAuto-generatedmethodstub
System.out.println("查询客户");
return"fanhuizhi";
}
publicvoidupdate(){
//TODOAuto-generatedmethodstub
System.out.println("修改客户");
}
}

第三步:使用AspectJ注解形式:

packagecn.spring3.demo1;
importorg.aspectj.lang.JoinPoint;
importorg.aspectj.lang.ProceedingJoinPoint;
importorg.aspectj.lang.annotation.After;
importorg.aspectj.lang.annotation.AfterReturning;
importorg.aspectj.lang.annotation.AfterThrowing;
importorg.aspectj.lang.annotation.Around;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.annotation.Before;
importorg.aspectj.lang.annotation.Pointcut;
/**
*@authorNOP切面类：就是切点与增强结合
*前置增强
*/
@Aspect
publicclassMyAspect{
@Before(value="execution(*cn.spring3.demo1.UserDao.add(..))")//这里写表达式，写哪些类需要添加
publicvoidbefore(JoinPointjoinpoint){
System.out.println("前置增强..."+joinpoint);
}

@AfterReturning(value="execution(*cn.spring3.demo1.UserDao.find(..))",returning="returnVal")//这里写表达式，写哪些类需要添加
publicvoidafterReturning(ObjectreturnVal){
System.out.println("后置增强..."+"方法的返回值"+returnVal);
}

@Around(value="execution(*cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
publicObjectaround(ProceedingJoinPointproceedingJoinPoint)throwsThrowable{
System.out.println("环绕前增强...");
Objectobj=proceedingJoinPoint.proceed();
System.out.println("环绕后增强...");
returnobj;
}

@AfterThrowing(value="execution(*cn.spring3.demo1.UserDao.delete(..))",throwing="ex")//这里写表达式，写哪些类需要添加
publicvoidafterThrowing(Throwableex)throwsThrowable{
System.out.println("不跑了出异常了..."+ex.getMessage());
}

//@After(value="execution(*cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
@After("MyAspect.MyPointCut()")//类名.方法名
publicvoidafter(){
System.out.println("最终通知");//不管有没有异常都会通知
}

//仅是为了定义一个通用的表达式
@Pointcut(value="execution(*cn.spring3.demo1.UserDao.delete(..))")
privatevoidMyPointCut(){
}
}

第四步:创建applicationContext.xml

xmlns:aop="http://www.springframework.org/schema/aop"

*引入aop的约束:
*

第五步，编写测试类

packagecn.spring3.demo1;

importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.annotation.Qualifier;
importorg.springframework.test.context.ContextConfiguration;
importorg.springframework.test.context.junit4.SpringJUnit4Cla***unner;

/**
*@authorNOP
*自动方式代理没有切点切面的增强
*/
@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration("classpath:applicationContext.xml")
publicclassSpringTest1{
@Autowired
@Qualifier("userDao")
privateUserDaouserDao;

@Test
publicvoiddemo1(){
System.out.println("-----------------");
userDao.add();
System.out.println("-----------------");
userDao.find();
System.out.println("-----------------");
userDao.delete();
System.out.println("-----------------");
userDao.update();
System.out.println("-----------------");
}
}
测试结果：
-----------------
前置增强...execution(voidcn.spring3.demo1.UserDao.add())
添加客户
-----------------
查询客户
后置增强...方法的返回值fanhuizhi
-----------------
环绕前增强...
删除客户
最终通知
不跑了出异常了.../byzero

AspectJ的通知类型:

@Before前置通知，相当于BeforeAdvice
就在方法之前执行.没有办法阻止目标方法执行的.
@AfterReturning后置通知，相当于AfterReturningAdvice
后置通知,获得方法返回值.
@Around环绕通知，相当于MethodInterceptor
在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.
@AfterThrowing抛出通知，相当于ThrowAdvice
@After最终final通知，不管是否异常，该通知都会执行
@DeclareParents引介通知，相当于IntroductionInterceptor(不要求掌握)

切点的定义:

@Pointcut("execution(*cn.itcast.spring3.demo1.UserDao.find(..))")
privatevoidmyPointcut(){}

面试:

Advisor和Aspect的区别?

Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.

Aspect:可以支持多个切点和多个通知的组合

基于XML

ProductDao

第一步:编写被增强的类:

packagecn.spring3.demo2;

publicclassProductDao{

publicvoidadd(){
//TODOAuto-generatedmethodstub
System.out.println("添加商品");
}

publicvoiddelete(){
//TODOAuto-generatedmethodstub
System.out.println("删除商品");

}

publicvoidfind(){
//TODOAuto-generatedmethodstub
System.out.println("查询商品");
inti=1/0;
}

publicStringupdate(){
//TODOAuto-generatedmethodstub
System.out.println("修改商品");
return"woshitest";
}

}

第二步:定义切面

packagecn.spring3.demo2;

importorg.aspectj.lang.ProceedingJoinPoint;

/**
*@authorNOP
*切面类
*/
publicclassMyAspectXML{
/*
*
*/
publicvoidbefore(){
System.out.println("前置增强");
}

publicvoidafterReturning(ObjectreturnVal){
System.out.println("后置增强"+returnVal);
}

publicObjectaround(ProceedingJoinPointproceedingJoinPoint)throwsThrowable{
System.out.println("环绕前增强");
Objectobj=proceedingJoinPoint.proceed();
System.out.println("环绕后增强");
returnobj;
}

publicvoidafterThrowing(Throwableex){
System.out.println("不跑了出异常了..."+ex.getMessage());
}

publicvoidafter(){
System.out.println("最终通知");//不管有没有异常都会通知
}
}

第三步:配置applicationContext.xml

第四步:编写测试类

packagecn.spring3.demo2;

importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.annotation.Qualifier;
importorg.springframework.test.context.ContextConfiguration;
importorg.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
publicclassSpringTest2{
@Autowired
@Qualifier("productDao")
privateProductDaoproductDao;

@Test
publicvoiddemo1(){
System.out.println("-----------------");
productDao.add();
System.out.println("-----------------");
productDao.find();
System.out.println("-----------------");
productDao.delete();
System.out.println("-----------------");
productDao.update();
System.out.println("-----------------");
}
}

测试结果：
-----------------
前置增强
添加商品
-----------------
查询商品
不跑了出异常了.../byzero
最终通知

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

Spring AspectJ AOP框架注解原理解析

热门推荐

随机推荐