1、Spring只支持方法拦截,也就是说,只能在方法的前后进行拦截,而不能在属性前后进行拦截。
2、Spring支持四种拦截类型:目标方法调用前(before),目标方法调用后(after),目标方法调用前后(around),以及目标方法抛出异常(throw)。
3、前置拦截的类必须实现MethodBeforeAdvice接口,实现其中的before方法。
4、后置拦截的类必须实现AfterReturningAdvice接口,实现其中的afterReturning方法。
5、前后拦截的类必须实现MethodInterceptor接口,实现其中的invoke方法。前后拦截是唯一可以控制目标方法是否被真正调用的拦截类型,也可以控制返回对象。而前置拦截或后置拦截不能控制,它们不能影响目标方法的调用和返回。
但是以上的拦截的问题在于,不能对于特定方法进行拦截,而只能对某个类的全部方法作拦截。所以下面引入了两个新概念:“切入点”和“引入通知”。
6、”切入点“的定义相当于更加细化地规定了哪些方法被哪些拦截器所拦截,而并非所有的方法都被所有的拦截器所拦截。在ProxyFactoryBean的属性中,interceptorNames属性的对象也由拦截(Advice)变成了引入通知(Advisor),正是在Advisor中详细定义了切入点(PointCut)和拦截(Advice)的对应关系,比如常见的基于名字的切入点匹配(NameMatchMethodPointcutAdvisor类)和基于正则表达式的切入点匹配(RegExpPointcutAdvisor类)。这些切入点都属于”静态切入点“,因为他们只在代理创建的时候被创建一次,而不是每次运行都创建。
下面我们进行实例的开发
首先创建业务接口:
package AdvisorTest;
public interface Shopping ...{
public String buySomething(String type);
public String buyAnything(String type);
public void testException();
}
下面是业务实现类,我们的通知就是以这些实现类作为切面,在业务方法前后加入我们的通知代码
package AdvisorTest;
public class ShoppingImpl implements Shopping ...{
private Customer customer;
public Customer getCustomer() ...{
return customer;
}
public void setCustomer(Customer customer) ...{
this.customer = customer;
}
public String buySomething(String type) ...{
System.out.println(this.getCustomer().getName()+" bye "+type+" success");
return null;
}
public String buyAnything(String type) ...{
System.out.println(this.getCustomer().getName()+" bye "+type+" success");
return null;
}
public void testException()...{
throw new ClassCastException();
}
}
(1)前置通知
配置了前置通知的bean,在执行业务方法前,均会执行前置拦截器的before方法
package AdvisorTest;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
//前置通知
public class WelcomeAdvice implements MethodBeforeAdvice ...{
public void before(Method method, Object[] args, Object obj)
throws Throwable ...{
String type=(String)args[0];
System.out.println("Hello welcome to bye "+type);
}
}
(2)后置通知
配置了后置通知的bean,在执行业务方法后,均会执行后置拦截器的afterReturnning方法 package AdvisorTest;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
//后置通知
public class ThankYouAdvice implements AfterReturningAdvice ...{
public void afterReturning(Object obj, Method method, Object[] arg1,
Object arg2) throws Throwable ...{
String type=(String)arg1[0];
System.out.println("Hello Thankyou to bye "+type);
}
}
(3)环绕通知
配置了环绕通知的bean,在执行业务方法前后,均会执行环绕拦截器的invoke方法
需要注意的是必须调用目标方法,如不调用,目标方法将不被执行
package AdvisorTest;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class MethodAdvisor implements MethodInterceptor ...{
public Object invoke(MethodInvocation invocation) throws Throwable ...{
String str=(String)invocation.getArguments()[0];
System.out.println("this is before"+str+" in MethodInterceptor");
Object obj=invocation.proceed(); //调用目标方法,如不调用,目标方法将不被执行
System.out.println("this is after"+str+" in MethodInterceptor");
return null;
}
}
(4)异常通知
ThrowsAdvice是一个标示接口,我们可以在类中定义一个或多个,来捕获定义异常通知的bean抛出的异常,并在抛出异常前执行相应的方法
public void afterThrowing(Throwable throwa){}或者
public void afterThrowing(Method method,Object[] args,Object target,Throwable throwable){
package AdvisorTest;
import org.springframework.aop.ThrowsAdvice;
public class ExceptionAdvisor implements ThrowsAdvice ...{
public void afterThrowing(ClassCastException e)...{
System.out.println("this is from exceptionAdvisor");
}
}
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >
<beans>
<bean id="customer" class="AdvisorTest.Customer">
<constructor-arg index="0">
<value>gaoxiang</value>
</constructor-arg>
<constructor-arg index="1">
<value>26</value>
</constructor-arg>
</bean>
<bean id="shoppingImpl" class="AdvisorTest.ShoppingImpl">
<property name="customer">
<ref local="customer"/>
</property>
</bean>
<!-- 前置通知 -->
<bean id="welcomeAdvice" class="AdvisorTest.WelcomeAdvice"/>
<bean id="welcomeAdviceShop" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>AdvisorTest.Shopping</value>
</property>
<property name="target">
<ref local="shoppingImpl"/>
</property>
<property name="interceptorNames">
<list>
<value>welcomeAdvice</value>
</list>
</property>
</bean>
<!-- 后置通知 -->
<bean id="thankyouAdvice" class="AdvisorTest.ThankYouAdvice"/>
<bean id="thankyouAdviceShop" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>AdvisorTest.Shopping</value>
</property>
<property name="target">
<ref local="shoppingImpl"/>
</property>
<property name="interceptorNames">
<list>
<value>thankyouAdvice</value>
</list>
</property>
</bean>
<!-- 环绕通知 -->
<bean id="methodAdvice" class="AdvisorTest.MethodAdvisor"/>
<bean id="methodAdviceShop" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>AdvisorTest.Shopping</value>
</property>
<property name="target">
<ref local="shoppingImpl"/>
</property>
<property name="interceptorNames">
<list>
<value>methodAdvice</value>
</list>
</property>
</bean>
<!-- 异常通知 -->
<bean id="exceptionAdvice" class="AdvisorTest.ExceptionAdvisor"/>
<bean id="exceptionAdviceShop" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>AdvisorTest.Shopping</value>
</property>
<property name="target">
<ref local="shoppingImpl"/>
</property>
<property name="interceptorNames">
<list>
<value>exceptionAdvice</value>
</list>
</property>
</bean>
</beans>
测试代码:
package AdvisorTest;
import java.io.File;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
public class TestAdvisor ...{
public static void main(String[] args) ...{
String filePath=System.getProperty("user.dir")+File.separator+"AdvisorTest"+File.separator+"hello.xml";
BeanFactory factory=new XmlBeanFactory(new FileSystemResource(filePath));
Shopping shopping=null;
System.out.println("不使用任何通知");
shopping=(Shopping)factory.getBean("shoppingImpl");
shopping.buySomething("something");
shopping.buyAnything("anything");
System.out.println("使用前置通知");
shopping=(Shopping)factory.getBean("welcomeAdviceShop");
shopping.buySomething("something");
shopping.buyAnything("anything");
System.out.println("使用后置通知");
shopping=(Shopping)factory.getBean("thankyouAdviceShop");
shopping.buySomething("something");
shopping.buyAnything("anything");
System.out.println("使用环绕通知");
shopping=(Shopping)factory.getBean("methodAdviceShop");
shopping.buySomething("something");
shopping.buyAnything("anything");
System.out.println("使用异常通知");
shopping=(Shopping)factory.getBean("exceptionAdviceShop");
shopping.testException();
}
}
运行结果一目了然:
不使用任何通知
gaoxiang bye something success
gaoxiang bye anything success
使用前置通知
Hello welcome to bye something
gaoxiang bye something success
Hello welcome to bye anything
gaoxiang bye anything success
使用后置通知
gaoxiang bye something success
Hello Thankyou to bye something
gaoxiang bye anything success
Hello Thankyou to bye anything
使用环绕通知
this is beforesomething in MethodInterceptor
gaoxiang bye something success
this is aftersomething in MethodInterceptor
this is beforeanything in MethodInterceptor
gaoxiang bye anything success
this is afteranything in MethodInterceptor
使用异常通知
this is from exceptionAdvisor
相关推荐
Spring_AOP四种创建通知(拦截器)类型,介绍的比较详细,有实例
Spring AOP 拦截器 Advisor Spring AOP 拦截器 Advisor
springboot spring aop 拦截器 注解方式实现脱敏(涉及到:pom.xml -->application.properties --->启动类-->拦截器)
SpringAOP原理及拦截器.pdf
SpringAOP原理及拦截器.docx
SpringAOP原理及拦截器.doc
一个基于配置文件的Spring AOP的实现。实现了前置通知,后置通知,以及拦截器的功能,配置中有详细的注释。
Spring源代码解析(七):Spring_AOP中对拦截器调用的实现.doc
本篇文章主要介绍了详解Spring AOP 拦截器的基本实现,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
常用拦截 拦截器HandlerInterceptor 拦截器MethodInterceptor 添加依赖 创建启动类 创建拦截器类 创建控制器 监控control请求耗时,提高性能
非常简单的aop例子,可以从该离子出发隐身出很多其他的问题的思考。
struts2+spring4+mybatis3,登录jquery ajax,struts拦截器,springAOP的例子。带部分注释。
Spring Boot 整合Mybatis、Druid、PageHelper、Swagger 、AOP、过滤器、拦截器、thymeleaf 基础入门demo
内含有mybatis 拦截器实现的分页代码,spring 的事务和aop 测试、和反射工具类
spring拦截器,高级参数绑定,controller返回值
Spring-AOP-利用java中的动态代理和Spring的拦截器做到AOP
SpringMVC学习(十二)——SpringMVC中的拦截器
SpringAOP与SpringMVC拦截器两种方式实现权限管控,前台xml读取配置根据登录用户判断button是否enable
本篇文章主要介绍了spring boot如何使用spring AOP实现拦截器,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧