spring教程--AOP详解
2017-04-20 11:12
447 查看
1 Spring中的AOP
1.1 Spring的传统AOP :
AOP:不是由Spring定义.AOP联盟的组织定义.Spring中的通知:(增强代码)
前置通知 org.springframework.aop.MethodBeforeAdvice
在目标方法执行前实施增强
后置通知 org.springframework.aop.AfterReturningAdvice
在目标方法执行后实施增强
环绕通知 org.aopalliance.intercept.MethodInterceptor
在目标方法执行前后实施增强
异常抛出通知 org.springframework.aop.ThrowsAdvice
在方法抛出异常后实施增强
引介通知 org.springframework.aop.IntroductionInterceptor(课程不讲.)
在目标类中添加一些新的方法和属性
1.2 Spring中的切面类型:
Advisor : Spring中传统切面.Advisor:都是有一个切点和一个通知组合.
Aspect:多个切点和多个通知组合.
Advisor : 代表一般切面,Advice本身就是一个切面,对目标类所有方法进行拦截(* 不带有切点的切面.针对所有方法进行拦截)
PointcutAdvisor : 代表具有切点的切面,可以指定拦截目标类哪些方法(带有切点的切面,针对某个方法进行拦截)
IntroductionAdvisor : 代表引介切面,针对引介通知而使用切面(不要求掌握)
1.3 Spring的AOP的开发:
1.3.1 针对所有方法的增强:(不带有切点的切面)
第一步:导入相应jar包.* spring-aop-3.2.0.RELEASE.jar
* com.springsource.org.aopalliance-1.0.0.jar
第二步:编写被代理对象:
* CustomerDao接口
* CustoemrDaoImpl实现类
第三步:编写增强的代码:
public class MyBeforeAdvice implements MethodBeforeAdvice{ /** * method:执行的方法 * args:参数 * target:目标对象 */ public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println("前置增强..."); } }
第四步:生成代理:(配置生成代理:)
生成代理Spring基于ProxyFactoryBean类.底层自动选择使用JDK的动态代理还是CGLIB的代理.
属性:
target : 代理的目标对象
proxyInterfaces : 代理要实现的接口
如果多个接口可以使用以下格式赋值
<list>
<value></value>
....
</list>
proxyTargetClass : 是否对类代理而不是接口,设置为true时,使用CGLib代理
interceptorNames : 需要织入目标的Advice
singleton : 返回代理是否为单实例,默认为单例
optimize : 当设置为true时,强制使用CGLib
<!-- 定义目标对象 --> <bean id="customerDao" class="com.sihai.spring3.demo3.CustomerDaoImpl"></bean> <!-- 定义增强 --> <bean id="beforeAdvice" class="com.sihai.spring3.demo3.MyBeforeAdvice"></bean> <!-- Spring支持配置生成代理: --> <bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <!-- 设置目标对象 --> <property name="target" ref="customerDao"/> <!-- 设置实现的接口 ,value中写接口的全路径 --> <property name="proxyInterfaces" value="com.sihai.spring3.demo3.CustomerDao"/> <!-- 需要使用value:要的名称 --> <property name="interceptorNames" value="beforeAdvice"/> </bean>
注入的时候要注入代理对象:
@Autowired // @Qualifier("customerDao")// 注入是真实的对象,必须注入代理对象. @Qualifier("customerDaoProxy") private CustomerDao customerDao;
1.3.2 带有切点的切面:(针对目标对象的某些方法进行增强)
PointcutAdvisor 接口:DefaultPointcutAdvisor 最常用的切面类型,它可以通过任意Pointcut和Advice 组合定义切面
RegexpMethodPointcutAdvisor 构造正则表达式切点切面
第一步:创建被代理对象.
OrderDao
第二步:编写增强的类:
public class MyAroundAdvice implements MethodInterceptor{ public Object invoke(MethodInvocation methodInvocation) throws Throwable { System.out.println("环绕前增强..."); Object result = methodInvocation.proceed();// 执行目标对象的方法 System.out.println("环绕后增强..."); return result; } }
第三步:生成代理:
<!-- 带有切点的切面 --> <!-- 定义目标对象 --> <bean id="orderDao" class="com.sihai.spring3.demo4.OrderDao"></bean> <!-- 定义增强 --> <bean id="aroundAdvice" class="com.sihai.spring3.demo4.MyAroundAdvice"></bean> <!-- 定义切点切面: --> <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <!-- 定义表达式,规定哪些方法执行拦截 --> <!-- . 任意字符 * 任意个 --> <!-- <property name="pattern" value=".*"/> --> <!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/> --> <!-- <property name="pattern" value=".*add.*"></property> --> <property name="patterns" value=".*add.*,.*find.*"></property> <!-- 应用增强 --> <property name="advice" ref="aroundAdvice"/> </bean> <!-- 定义生成代理对象 --> <bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <!-- 配置目标 --> <property name="target" ref="orderDao"></property> <!-- 针对类的代理 --> <property name="proxyTargetClass" value="true"></property> <!-- 在目标上应用增强 --> <property name="interceptorNames" value="myPointcutAdvisor"></property> </bean>
1.4 自动代理:
前面的案例中,每个代理都是通过ProxyFactoryBean织入切面代理,在实际开发中,非常多的Bean每个都配置ProxyFactoryBean开发维护量巨大自动创建代理(基于后处理Bean.在Bean创建的过程中完成的增强.生成Bean就是代理.)
BeanNameAutoProxyCreator 根据Bean名称创建代理
DefaultAdvisorAutoProxyCreator 根据Advisor本身包含信息创建代理
AnnotationAwareAspectJAutoProxyCreator 基于Bean中的AspectJ 注解进行自动代理
1.4.1 BeanNameAutoProxyCreator :按名称生成代理
<!-- 定义目标对象 --> <bean id="customerDao" class="com.sihai.spring3.demo3.CustomerDaoImpl"></bean> <bean id="orderDao" class="com.sihai.spring3.demo4.OrderDao"></bean> <!-- 定义增强 --> <bean id="beforeAdvice" class="com.sihai.spring3.demo3.MyBeforeAdvice"></bean> <bean id="aroundAdvice" class="com.sihai.spring3.demo4.MyAroundAdvice"></bean> <!-- 自动代理:按名称的代理 基于后处理Bean,后处理Bean不需要配置ID--> <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames" value="*Dao"/> <property name="interceptorNames" value="beforeAdvice"/> </bean>
1.4.2 DefaultAdvisorAutoProxyCreator :根据切面中定义的信息生成代理
<!-- 定义目标对象 --> <bean id="customerDao" class="com.sihai.spring3.demo3.CustomerDaoImpl"></bean> <bean id="orderDao" class="com.sihai.spring3.demo4.OrderDao"></bean> <!-- 定义增强 --> <bean id="beforeAdvice" class="com.sihai.spring3.demo3.MyBeforeAdvice"></bean> <bean id="aroundAdvice" class="com.sihai.spring3.demo4.MyAroundAdvice"></bean> <!-- 定义一个带有切点的切面 --> <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="pattern" value=".*add.*"/> <property name="advice" ref="aroundAdvice"/> </bean> <!-- 自动生成代理 --> <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
区分基于ProxyFattoryBean的代理与自动代理区别
ProxyFactoryBean:先有被代理对象,将被代理对象传入到代理类中生成代理.
自动代理基于后处理Bean.在Bean的生成过程中,就产生了代理对象,把代理对象返回.生成Bean已经是代理对象.
2 Spring的AspectJ的AOP
AspectJ是一个面向切面的框架,它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ 是AspectJ1.5新增功能,通过JDK5注解技术,允许直接在Bean类中定义切面
新版本Spring框架,建议使用AspectJ方式来开发AOP
AspectJ表达式:
* 语法:execution(表达式)
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
* execution(“* com.sihai.spring3.demo1.dao.*(..)”)---只检索当前包
* execution(“* com.sihai.spring3.demo1.dao..*(..)”)---检索包及当前包的子包.
* execution(* com.sihai.dao.GenericDAO+.*(..))---检索GenericDAO及子类
AspectJ增强:
@Before 前置通知,相当于BeforeAdvice
@AfterReturning 后置通知,相当于AfterReturningAdvice
@Around 环绕通知,相当于MethodInterceptor
@AfterThrowing抛出通知,相当于ThrowAdvice
@After 最终final通知,不管是否异常,该通知都会执行
@DeclareParents 引介通知,相当于IntroductionInterceptor (不要求掌握)
2.1 基于注解:
第一步:引入相应jar包.* aspectj依赖aop环境.
* spring-aspects-3.2.0.RELEASE.jar
* com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
第二步:编写被增强的类:
* UserDao
第三步:使用AspectJ注解形式:
@Aspect public class MyAspect { @Before("execution(* com.sihai.spring3.demo1.UserDao.add(..))") public void before(){ System.out.println("前置增强...."); } }
第四步:创建applicationContext.xml
* 引入aop的约束:
* <aop:aspectj-autoproxy /> --- 自动生成代理:
* 底层就是AnnotationAwareAspectJAutoProxyCreator
<aop:aspectj-autoproxy /> <bean id="userDao" class="com.sihai.spring3.demo1.UserDao"></bean> <bean id="myAspect" class="com.sihai.spring3.demo1.MyAspect"></bean>
AspectJ的通知类型:
@Before 前置通知,相当于BeforeAdvice* 就在方法之前执行.没有办法阻止目标方法执行的.
@AfterReturning 后置通知,相当于AfterReturningAdvice
* 后置通知,获得方法返回值.
@Around 环绕通知,相当于MethodInterceptor
* 在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.
@AfterThrowing抛出通知,相当于ThrowAdvice
@After 最终final通知,不管是否异常,该通知都会执行
@DeclareParents 引介通知,相当于IntroductionInterceptor (不要求掌握)
切点的定义:
@Pointcut("execution(* com.sihai.spring3.demo1.UserDao.find(..))") private void myPointcut(){}
Advisor和Aspect的区别
* Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.
* Aspect:可以支持多个切点和多个通知的组合.
2.2 基于XML:
第一步:编写被增强的类:ProductDao
第二步:定义切面
第三步:配置applicationContext.xml
2.2.1 前置通知:
代码:
public void before(){ System.out.println("前置通知..."); }
配置:
<aop:config> <!-- 定义切点: --> <aop:pointcut expression="execution(* com.sihai.spring3.demo2.ProductDao.add(..))" id="mypointcut"/> <aop:aspect ref="myAspectXML"> <!-- 前置通知 --> <aop:before method="before" pointcut-ref="mypointcut"/> </aop:aspect> </aop:config>
2.2.2 后置通知:
代码:
public void afterReturing(Object returnVal){ System.out.println("后置通知...返回值:"+returnVal); }
配置:
<aop:config> <!-- 定义切点: --> <aop:pointcut expression="execution(* com.sihai.spring3.demo2.ProductDao.add(..))" id="mypointcut"/> <aop:aspect ref="myAspectXML"> <!-- 后置通知 --> <aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/> </aop:aspect> </aop:config>
2.2.3 环绕通知:
代码:
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{ System.out.println("环绕前增强...."); Object result = proceedingJoinPoint.proceed(); System.out.println("环绕后增强...."); return result; }
配置:
<aop:config> <!-- 定义切点: --> <aop:pointcut expression="execution(* com.sihai.spring3.demo2.ProductDao.add(..))" id="mypointcut"/> <aop:aspect ref="myAspectXML"> <!-- 前置通知 --> <!-- <aop:before method="before" pointcut-ref="mypointcut"/> --> <!-- 后置通知 --> <!-- <aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/> --> <!-- 环绕通知 --> <aop:around method="around" pointcut-ref="mypointcut"/> </aop:aspect> </aop:config>
2.2.4 异常通知:
代码;
public void afterThrowing(Throwable e){ System.out.println("异常通知..."+e.getMessage()); }
配置;
<aop:config> <!-- 定义切点: --> <aop:pointcut expression="execution(* com.sihai.spring3.demo2.ProductDao.add(..))" id="mypointcut"/> <aop:aspect ref="myAspectXML"> <!-- 异常通知 --> <aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/> </aop:aspect> </aop:config>
2.2.5 最终通知:
代码:
public void after(){ System.out.println("最终通知...."); }
配置:
<aop:config> <!-- 定义切点: --> <aop:pointcut expression="execution(* com.sihai.spring3.demo2.ProductDao.add(..))" id="mypointcut"/> <aop:aspect ref="myAspectXML"> <!-- 最终通知 --> <aop:after method="after" pointcut-ref="mypointcut"/> </aop:aspect> </aop:config>
相关文章推荐
- [教程]spring AOP详解
- Spring 教程 - Spring AOP 详解
- Spring4.3x教程之三AOP详解
- Spring AOP入门实例详解
- Spring AOP中文教程
- Spring AOP 的proxy详解
- Spring之AOP配置文件详解
- Spring AOP中文教程
- Spring AOP 详解
- Spring.NET教程(十二)——AOP的通知类型(基础篇)
- Spring.NET教程(十三)——AOP的配置(基础篇)
- 开源框架spring详解-----AOP的深刻理解
- [转]Spring AOP中文教程
- Spring AOP详解(转)
- Spring AOP 详解
- Spring AOP 详解
- Spring AOP编程的教程
- Spring AOP中文教程
- 15_传智播客Spring2.5视频教程_使用JDK中的Proxy技术实现AOP功能 2
- Spring AOP深度详解 综合