1.经典的基于代理的AOP
[1]前置通知
public class BeforeAdvice implements MethodBeforeAdvice{
@Override
public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
System.out.println("前置通知");
/*
* arg0 切点的方法
* arg1 切点的方法形参
* arg3 切点所在的对象
*/
}
}
[2]后置通知
public class AfterAdvice implements AfterReturningAdvice{
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("后置通知");
}
}
[3]环绕通知
public class AroundAdvice implements MethodInterceptor{
@Override
public Object invoke(MethodInvocation arg0) throws Throwable {
System.out.println("环绕通知前");
Object proceed = arg0.proceed();
System.out.println("环绕通知后");
return proceed;
}
}
[4]异常通知
public class ExceptionAdvice implements ThrowsAdvice{
public void afterThrowing(Exception ex){
System.err.println(ex.getMessage());
System.out.println("异常通知");
}
}
[5]application.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册代理目标类 -->
<bean id="someServiceImpl" class="com.bjsxt.service.SomeServiceImpl"></bean>
<!-- 注册前置通知 -->
<bean id="beforeAdvice" class="com.bjsxt.advice.BeforeAdvice"></bean>
<!-- 注册后置通知 -->
<bean id="afterAdvice" class="com.bjsxt.advice.AfterAdvice"></bean>
<!-- 注册环绕通知 -->
<bean id="aroundAdvice" class="com.bjsxt.advice.AroundAdvice"></bean>
<!-- 注入异常通知 -->
<bean id="exceptionAdvice" class="com.bjsxt.advice.ExceptionAdvice"></bean>
<!-- 注册代理工厂Bean -->
<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置目标类-->
<property name="targetName" value="someServiceImpl"></property>
<!-- 配置拦截时执行的通知 -->
<property name="interceptorNames">
<!-- 字符串数组 -->
<!-- 方式一 在property标签中的value属性中用,分隔注入 例如:(value="beforeAdvice,afterAdvice")-->
<!-- 方式二 (数组注入)-->
<array>
<value>beforeAdvice</value>
<value>afterAdvice</value>
<value>aroundAdvice</value>
<value>exceptionAdvice</value>
</array>
</property>
<!-- 配置目标类的接口 -->
<property name="interfaces">
<list>
<!-- (字节码对象数组)注意:字节码对象可以直接在value属性中表示 -->
<value>com.bjsxt.service.SomeService</value>
</list>
</property>
</bean>
</beans>
QQ截图20190214203643.png
2.通过AspectJ提供的注解实现AOP
AspectJ对AOP的实现
对于AOP这种编程思想，很多框架都进行了实现。Spring就是其中之一，可以完成面向切面编程。然而，AspectJ也实现了AOP的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以，Spring又将AspectJ的对于AOP的实现也引入到了自己的框架中。
在Spring中使用AOP开发时，一般使用AspectJ的实现方式。
AspectJ中常用的通知有五种类型：
前置通知
后置通知
环绕通知
异常通知
最终通知:无论程序执行是否正常，该通知都会执行。类似于try..catch中finally代码块。
AspectJ的切入点表达式 (execution)
举例：
execution(public * (..))
指定切入点为：任意公共方法。
execution( set (..))
指定切入点为：任何一个以"set"开始的方法。
execution( com.xyz.service..(..))
指定切入点为：定义在service包里的任意类的任意方法。
execution(* com.xyz.service...(..))
指定切入点为：定义在service包或者子包里的任意类的任意方法。".."出现在类名中时，后面必须跟""，表示包、子包下的所有类。
execution( .service..(..))
指定只有一级包下的serivce子包下所有类(接口)中的所有方法为切入点
execution( ..service..*(..))
指定所有包下的serivce子包下所有类(接口)中的所有方法为切入点
untitled.png
切入点表达式要匹配的对象就是目标方法的方法名。所以，execution表达式中明显就是方法的签名。注意，表达式中加[ ]的部分表示可省略部分，各部分间用空格分开。在其中可以使用以下符号
untitled2.png
代码示例
@Component("myAspect")
@Aspect //表明当前类是一个切面
public class MyAspect {
@Before(value="execution(* *..service.*.*(..))")
public void before(JoinPoint joinPoint) throws Throwable {
System.out.println("前置通知"+jp);
//通过JoinPoint 获取切点方法的参数列表集合
Object[] args = joinPoint.getArgs();
//获取切点所在的目标对象
Object target = joinPoint.getTarget();
//获取切点的方法的对象
Signature signature = joinPoint.getSignature();
MethodSignature ms = (MethodSignature)signature;
Method method = ms.getMethod();
}
@Around(value="execution(* *..service.*.*(..))")
public Object around(ProceedingJoinPoint arg0) throws Throwable {
System.out.println("环绕通知前");
Object proceed = arg0.proceed();
if(proceed!=null){
System.out.println(proceed.toString().toUpperCase());
}
System.out.println("环绕通知后");
return proceed;
}
@AfterReturning(value="execution(* *..service.*.*(..))",returning="result")
public void afterReturning(Object result) throws Throwable {
System.out.println("后置通知");
System.out.println("后置通知获取返回值:"+result);
}
@AfterThrowing(value="execution(* *..service.*.*(..))" ,throwing="ex")
public void afterThrowing(Exception ex){
System.out.println("异常通知"+ex.getMessage());
}
//使用@After(value="pointcut()")，表示继承了方法pointcut（）的切入表达式：execution(* *..service.*.*(..))。
@After(value="pointcut()")
public void after(){
System.out.println("最终通知");
}
@Pointcut("execution(* *..service.*.*(..))")
public void pointcut(){
}
}
application.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: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.xsd">
<context:component-scan base-package="com.terence.aop.aspectj"/>
<!-- 配置切面自动代理 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
3.AspectJ通过XML方式实现AOP
<!-- 注册目标类 -->
<bean id="someServiceImpl" class="com.bjsxt.service.impl.SomeServiceImpl"></bean>
<!-- 注册切面-->
<bean id="myAspect" class="com.bjsxt.aspects.MyAspect"></bean>
<!-- aop配置 -->
<aop:config>
<!-- 指定切入点 -->
<aop:pointcut expression="execution(* *..service.*.doSome(..))" id="doSomePC"/>
<aop:pointcut expression="execution(* *..service.*.doOther(..))" id="doOtherPC"/>
<!-- 指定切面 -->
<aop:aspect ref="myAspect">
<!-- 指定切面当中的前置通知方法 -->
<aop:before method="before" pointcut-ref="doSomePC"/>
<aop:before method="before(org.aspectj.lang.JoinPoint)" pointcut-ref="doSomePC"/>
<!-- 指定切面当中的后置通知方法 -->
<aop:after-returning method="afterReturning(java.lang.Object)" pointcut-ref="doOtherPC" returning="result"/>
<!-- 指定切面当中的环绕通知方法 -->
<aop:around method="around" pointcut-ref="doOtherPC"/>
<!-- 指定切面当中的异常通知方法 -->
<aop:after-throwing method="afterThrowing(java.lang.Exception)" pointcut-ref="doSomePC" throwing="ex"/>
<!-- 指定切面当中的最终通知方法 -->
<aop:after method="after" pointcut-ref="doSomePC"/>
</aop:aspect>
</aop:config>
4.基于Scheme-base的AOP
<?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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册user实体类 -->
<bean id="user" class="com.bjsxt.pojo.User"></bean>
<!-- 注册前置通知 -->
<bean id="before" class="com.bjsxt.advice.BeforeAdvice"></bean>
<!-- 注册后置通知 -->
<bean id="after" class="com.bjsxt.advice.AfterAdvice"></bean>
<!-- 注册环绕通知 -->
<bean id="run" class="com.bjsxt.advice.RunAdvice"></bean>
<!-- 注册异常通知 -->
<bean id="exception" class="com.bjsxt.advice.ExceptionAdvice"></bean>
<!-- 配置aop -->
<aop:config>
<!-- 选择切点 -->
<!-- 指定方法的切点 -->
<aop:pointcut expression="execution(* com.bjsxt.pojo.User.b(String))" id="point"/>
<!-- ..代表有参数和无参数都行 -->
<aop:pointcut expression="execution(* com.bjsxt.pojo.User.b(..))" id="point2"/>
<!-- *代表通配符 (User类的所有方法都是切点) -->
<aop:pointcut expression="execution(* com.bjsxt.pojo.User.*(..))" id="point3"/>
<!-- pojo报下的所有方法都是切点 -->
<aop:pointcut expression="execution(* com.bjsxt.pojo.*.*(..))" id="point4"/>
<!-- 定义切面 -->
<aop:advisor advice-ref="before" pointcut-ref="point"/>
<aop:advisor advice-ref="after" pointcut-ref="point"/>
<aop:advisor advice-ref="run" pointcut-ref="point"/>
<aop:advisor advice-ref="exception" pointcut-ref="point"/>
</aop:config>
</beans>
