----------------------Spring AOP介绍------------------
1.编程范式概念
面向过程编程:C
面向对象编程:c++,Java
函数式编程
事件驱动编程:GUI编程
面向切面编程(AOP)
2.AOP是什么
(1)是一种编程范式,不是编程语言
(2)解决特定问题,不能解决所有问题
(3是OOP的补充,不是替代。
3.AOP初衷:
1.解决代码重复问题,增加代码的可读性与可维护性
2.关注点分离,使程序员可以将更多的精力放在开发主要功能中。
4.SpringAOP的两种实现方式
1.基于xml配置的方式
2.基于注解的方式(重点)
5.AOP中名词:
Aspect:切面(切入点+通知)
join point:连接点,所有可以织入通知的方法
point cut:切入点,需要|已经织入通知的方法
advice:通知。需要增强的代码
weaving:织入,动词,将通知应用到切点的过程
target:目标对象
proxy:代理对象
注解AOP:
表达式:
- 选择器类型
- wildcards通配符:
* 匹配任意数量的字符
+ 匹配定指定类及其子类
.. 一般用于匹配任意数的子包或参数
- operators:运算符
&& 与操作符
|| 或操作符
! 非操作符
6.将通知织入切点的时机
1.编译时期(Aspect)
2.类加载时期(Aspect5+)
3.运行时期(Spring AOP)
从静态代理到动态代理(基于接口的代理与基于继承的代理)。
---------------------------Spring AOP实战--------------------
1.基于xml配置方式的AOP实现
1.编写通知类:(通过反射精确的定位到每个方法可以做一些详细的处理,两种方式定位到方法)
package cn.qlq.XMLaspect; import java.lang.reflect.Method;
import java.util.Arrays; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature; //xml切面
public class MyAdvice {
// 前置通知
public void before(JoinPoint joinPoint) throws Exception {
System.out.println("---------------前置通知开始~~~~~~~~~~~");
// 获取到类名
String targetName = joinPoint.getTarget().getClass().getName();
System.out.println("代理的类是:" + targetName);
// 获取到方法名
String methodName = joinPoint.getSignature().getName();
System.out.println("增强的方法是:" + methodName);
// 获取到参数
Object[] parameter = joinPoint.getArgs();
System.out.println("传入的参数是:" + Arrays.toString(parameter));
// 获取字节码对象
Class<?> targetClass = Class.forName(targetName);
// 获取所有的方法
Method[] methods = targetClass.getMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs.length == parameter.length) {
System.out.println("找到这个方法");
//处理一些业务逻辑
break;
}
}
}
System.out.println("---------------前置通知结束~~~~~~~~~~~");
} // 后置通知(异常发生后不会调用)
public void afterRunning() {
System.out.println("这是后置通知(异常发生后不会调用)");
} // 环绕通知(推荐下面这种方式获取方法)
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("----------------环绕通知之前 的部分----------------");
// 获取到类名
String targetName = pjp.getTarget().getClass().getName();
System.out.println("代理的类是:" + targetName);
// 获取到参数
Object[] parameter = pjp.getArgs();
System.out.println("传入的参数是:" + Arrays.toString(parameter));
// 获取到方法签名,进而获得方法
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
System.out.println("增强的方法名字是:" + method.getName());
//处理一些业务逻辑 // 获取参数类型
Class<?>[] parameterTypes = method.getParameterTypes();
System.out.println("参数类型是:" + parameterTypes.toString()); //让方法执行(proceed是方法的返回结果,可以针对返回结果处理一下事情)
System.out.println("--------------方法开始执行-----------------");
Object proceed = pjp.proceed(); //环绕通知之后的业务逻辑部分
System.out.println("----------------环绕通知之后的部分----------------");
return proceed;
}
// 异常通知
public void afterException() {
System.out.println("这是异常通知(发生异常后调用)~~~~~~~~~~~");
} // 最终通知(发生异常也会在最终调用)
public void after() {
System.out.println("这是后置通知(发生异常也会在最终调用)");
}
}
2.编写service接口和实现类(需要被增强的类)
- UserService.java
package cn.qlq.service; import java.sql.SQLException; public interface UserService { void save();
void save(String userId)throws Exception;
void update();
void delete();
void find();
}
- UserServiceImpl.java
package cn.qlq.service; import org.springframework.stereotype.Service; @Service("userService")
public class UserServiceImpl implements UserService { @Override
public void save() {
System.out.println("保存用户。。。无参数");
} @Override
public void save(String userId) throws Exception {
int i = 1 / 0;
System.out.println("保存用户.....(有参数)");
} @Override
public void update() {
System.out.println("更新用户....");
} @Override
public void delete() {
System.out.println("删除用户....");
} @Override
public void find() {
System.out.println("查找用户");
}
}
3.xml配置切入点+通知形成切面
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns="http://www.springframework.org/schema/beans" 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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
<!-- 1.首先导入aop约束,在beans元素添加命名空间 -->
<context:component-scan base-package="cn.qlq.service"></context:component-scan>
<!-- 3.配置通知对象 -->
<bean name="advice" class="cn.qlq.XMLaspect.MyAdvice"></bean>
<!-- 4.通知对象织入目标对象 .expression:切入点表达式。id:切入点名字
public void cn.qlq.service.UserServiceImpl.save() 对指定类型指定返回值的空参方法进行增强
void cn.qlq.service.UserServiceImpl.save() public可以省去,默认public
* cn.qlq.service.UserServiceImpl.save() 对返回类型不做要求,可以对任何返回类型织入
* cn.qlq.service.UserServiceImpl.*() 对返回类型不做要求,对方法名字不做要求
* cn.qlq.service.UserServiceImpl.*(..) 对返回类型不做要求,对方法名字不做要求,对参数也不做要求
* cn.qlq.service.*ServiceImpl.*(..) 对service包下所有以ServiceImpl结尾的类中的任意参数的任意方法增强
* cn.qlq.service..*ServiceImpl.*(..) 与上面不同的是对service包的子包也要进行增强(一般不用) -->
<aop:config>
<!-- 配置切点 -->
<aop:pointcut expression="execution(* cn.qlq.service.*ServiceImpl.*(..))" id="pc"/>
<!-- 将通知织入切点形成切面 -->
<aop:aspect ref="advice">
<aop:before method="before" pointcut-ref="pc"/>
<aop:after-returning method="afterRunning" pointcut-ref="pc"/>
<aop:after method="after" pointcut-ref="pc"/>
<aop:around method="around" pointcut-ref="pc"/>
<aop:after-throwing method="afterException" pointcut-ref="pc"/>
</aop:aspect>
</aop:config> </beans>
4.编写测试类:
package cn.qlq.test; import javax.annotation.Resource; import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import cn.qlq.service.UserService; //帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用的配置文件
@ContextConfiguration("classpath:cn/qlq/XMLaspect/applicationContext.xml")
public class SpringXMLAopTest { @Resource(name="userService")
private UserService us; @Test
public void fun1() throws Exception{
us.save("111");
} }
结果:
---------------前置通知开始~~~~~~~~~~~
代理的类是:cn.qlq.service.UserServiceImpl
增强的方法是:save
传入的参数是:[111]
找到这个方法
---------------前置通知结束~~~~~~~~~~~
----------------环绕通知之前 的部分----------------
代理的类是:cn.qlq.service.UserServiceImpl
传入的参数是:[111]
增强的方法名字是:save
参数类型是:[Ljava.lang.Class;@5eebd82d
--------------方法开始执行-----------------
保存用户.....(有参数)
这是后置通知(异常发生后不会调用)
这是后置通知(发生异常也会在最终调用)
----------------环绕通知之后的部分----------------
现在在程序中抛出一个异常,查看执行结果
@Override
public void save(String userId) throws Exception {
int i = 1 / 0;
System.out.println("保存用户.....(有参数)");
}
结果:
---------------前置通知开始~~~~~~~~~~~
代理的类是:cn.qlq.service.UserServiceImpl
增强的方法是:save
传入的参数是:[111]
找到这个方法
---------------前置通知结束~~~~~~~~~~~
----------------环绕通知之前 的部分----------------
代理的类是:cn.qlq.service.UserServiceImpl
传入的参数是:[111]
增强的方法名字是:save
参数类型是:[Ljava.lang.Class;@7022c24e
--------------方法开始执行-----------------
这是后置通知(发生异常也会在最终调用)
这是异常通知(发生异常后调用)~~~~~~~~~~~
通知执行顺序:
(1)没有异常(不会走异常通知)
前置通知->环绕通知之前部分->后置通知(异常不调用)->最终通知(异常也会调用)->环绕通知之后的部分
(2)有异常(不会走环绕通知的后半部分和后置通知)
前置通知->环绕通知之前部分->最终通知(异常也会调用)->异常通知
2.基于注解方式的AOP实现(重点)
1.applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p" xmlns="http://www.springframework.org/schema/beans"
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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
<!-- 1.开启注解AOP -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!-- 2.配置扫描的包 -->
<context:component-scan base-package="cn.qlq"></context:component-scan>
</beans>
2.通知类:
MyAdvice.java
package cn.qlq.annotationAOP; import java.lang.reflect.Method;
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.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component; @Aspect // 表示该类是一个通知类
@Component // 交给spring管理
public class MyAdvice { // 定义一个空方法,借用其注解抽取切点表达式
@Pointcut("execution(* cn.qlq.service.*ServiceImpl.*(..))")
public void pc() {
} // 前置通知
@Before("MyAdvice.pc()")
public void before(JoinPoint joinPoint) throws Exception {
System.out.println("---------------前置通知开始(注解)~~~~~~~~~~~");
// 获取到类名
String targetName = joinPoint.getTarget().getClass().getName();
System.out.println("代理的类是:" + targetName);
// 获取到方法名
String methodName = joinPoint.getSignature().getName();
System.out.println("增强的方法是:" + methodName);
// 获取到参数
Object[] parameter = joinPoint.getArgs();
System.out.println("传入的参数是:" + Arrays.toString(parameter));
// 获取字节码对象
Class<?> targetClass = Class.forName(targetName);
// 获取所有的方法
Method[] methods = targetClass.getMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs.length == parameter.length) {
System.out.println("找到这个方法");
break;
}
}
}
System.out.println("---------------前置通知结束(注解)~~~~~~~~~~~");
} // 后置通知(异常发生后不会调用)
@AfterReturning("MyAdvice.pc()")
public void afterRunning() {
System.out.println("这是后置通知(异常发生后不会调用)。。。。(注解)");
} // 环绕通知
@Around("MyAdvice.pc()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("----------------环绕通知之前 的部分(注解)----------------");
// 获取到类名
String targetName = pjp.getTarget().getClass().getName();
System.out.println("代理的类是:" + targetName);
// 获取到参数
Object[] parameter = pjp.getArgs();
System.out.println("传入的参数是:" + Arrays.toString(parameter));
// 获取到方法签名,进而获得方法
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
System.out.println("增强的方法名字是:" + method.getName());
// 获取参数类型
Class<?>[] parameterTypes = method.getParameterTypes();
System.out.println("参数类型是:" + parameterTypes.toString()); //让方法执行(proceed是拦截的方法的执行返回值,可以针对返回值做一些处理)
System.out.println("--------------方法开始执行-----------------");
Object proceed = pjp.proceed(); //环绕通知之后的业务逻辑部分
System.out.println("----------------环绕通知之后的部分(注解)----------------");
return proceed;
} // 异常通知
@AfterThrowing("MyAdvice.pc()")
public void afterException() {
System.out.println("这是异常通知(发生异常后调用)~~~~~~~~~~~(注解)");
} // 最终通知(发生异常也会在最终调用)
@After("MyAdvice.pc()")
public void after() {
System.out.println("这是最终通知(发生异常也会在最终调用)........(注解)");
}
}
3.UserService.java与UserServiceImpl.java同上
4.测试类:
package cn.qlq.test; import javax.annotation.Resource; import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import cn.qlq.service.UserService; //帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用的配置文件
@ContextConfiguration("classpath:cn/qlq/annotationAOP/applicationContext.xml")
public class SpringAnnotationAopTest { @Resource(name="userService")
private UserService us; @Test
public void fun1(){
us.save("111");
} }
结果:
----------------环绕通知之前 的部分(注解)----------------
代理的类是:cn.qlq.service.UserServiceImpl
传入的参数是:[111]
增强的方法名字是:save
参数类型是:[Ljava.lang.Class;@61d60df3
--------------方法开始执行(注解)------------------
---------------前置通知开始(注解)~~~~~~~~~~~
代理的类是:cn.qlq.service.UserServiceImpl
增强的方法是:save
传入的参数是:[111]
找到这个方法
---------------前置通知结束(注解)~~~~~~~~~~~
保存用户.....(有参数)
----------------环绕通知之后的部分(注解)-----------------
这是最终通知(发生异常也会在最终调用)........(注解)
这是后置通知(异常发生后不会调用)。。。。(注解)
注意,为了抽取切点表达式,我们将上面的通知类改为如下:
package cn.qlq.annotationAOP; import java.lang.reflect.Method;
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.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component; @Aspect // 表示该类是一个通知类
@Component // 交给spring管理
public class MyAdvice { // 定义一个空方法,借用其注解抽取切点表达式
@Pointcut("execution(* cn.qlq.service.*ServiceImpl.*(..))")
public void pc() {
} // 前置通知(下面两种方式均可以)
// @Before("MyAdvice.pc()")
@Before("pc()")
public void before(JoinPoint joinPoint) throws Exception {
System.out.println("---------------前置通知开始(注解)~~~~~~~~~~~");
// 获取到类名
String targetName = joinPoint.getTarget().getClass().getName();
System.out.println("代理的类是:" + targetName);
// 获取到方法名
String methodName = joinPoint.getSignature().getName();
System.out.println("增强的方法是:" + methodName);
// 获取到参数
Object[] parameter = joinPoint.getArgs();
System.out.println("传入的参数是:" + Arrays.toString(parameter));
// 获取字节码对象
Class<?> targetClass = Class.forName(targetName);
// 获取所有的方法
Method[] methods = targetClass.getMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs.length == parameter.length) {
System.out.println("找到这个方法");
break;
}
}
}
System.out.println("---------------前置通知结束(注解)~~~~~~~~~~~");
} // 后置通知(异常发生后不会调用)
@AfterReturning("MyAdvice.pc()")
public void afterRunning() {
System.out.println("这是后置通知(异常发生后不会调用)。。。。(注解)");
} // 环绕通知
@Around("MyAdvice.pc()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("----------------环绕通知之前 的部分(注解)----------------");
// 获取到类名
String targetName = pjp.getTarget().getClass().getName();
System.out.println("代理的类是:" + targetName);
// 获取到参数
Object[] parameter = pjp.getArgs();
System.out.println("传入的参数是:" + Arrays.toString(parameter));
// 获取到方法签名,进而获得方法
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
System.out.println("增强的方法名字是:" + method.getName());
// 处理一些业务逻辑 // 获取参数类型
Class<?>[] parameterTypes = method.getParameterTypes();
System.out.println("参数类型是:" + parameterTypes.toString()); // 让方法执行(proceed是方法的返回结果,可以针对返回结果做一些处理)
System.out.println("--------------方法开始执行(注解)------------------");
Object proceed = pjp.proceed(); // 环绕通知之后的业务逻辑部分
System.out.println("----------------环绕通知之后的部分(注解)-----------------");
return proceed;
} // 异常通知
@AfterThrowing("MyAdvice.pc()")
public void afterException() {
System.out.println("这是异常通知(发生异常后调用)~~~~~~~~~~~(注解)");
} // 最终通知(发生异常也会在最终调用)
@After("MyAdvice.pc()")
public void after() {
System.out.println("这是最终通知(发生异常也会在最终调用)........(注解)");
}
}
现在serviceImpl模拟抛出异常:
@Override
public void save(String userId) throws Exception {
int i = 1 / 0;
System.out.println("保存用户.....(有参数)");
}
结果:
----------------环绕通知之前 的部分(注解)----------------
代理的类是:cn.qlq.service.UserServiceImpl
传入的参数是:[111]
增强的方法名字是:save
参数类型是:[Ljava.lang.Class;@54b2a02f
--------------方法开始执行(注解)------------------
---------------前置通知开始(注解)~~~~~~~~~~~
代理的类是:cn.qlq.service.UserServiceImpl
增强的方法是:save
传入的参数是:[111]
找到这个方法
---------------前置通知结束(注解)~~~~~~~~~~~
这是最终通知(发生异常也会在最终调用)........(注解)
这是异常通知(发生异常后调用)~~~~~~~~~~~(注解)
总结:
1.注解解释
@Aspect:指明当前类是通知类
@Before:前置通知
@After:最终通知,发生异常也会调用,方法执行完之后执行
@AfterReturning:后置通知(异常发生不会调用),方法成功执行之后。
@Around:环绕通知
@AfterThrowing:异常通知,抛出异常之后
@Pointcut:抽取切点表达式,便于修改切点表达式
2.通知执行顺序(顺序和xml方式有点不一样)
没异常:(不会执行异常通知)
环绕通知之前部分->前置通知->环绕通知之后部分->最终通知->后置通知
有异常(不会执行后置通知和环绕通知后半部分)
环绕通知之前部分->前置通知->最终通知->异常通知
3.注解AOP几种切点表达式选择的使用:
1.within("xxx")表达式
// 匹配UserServiceImpl下面的所有方法
@Pointcut("within(cn.qlq.service.UserServiceImpl)")
public void pc() {
}
// 匹配cn.qlq包及其子包下面所有类的所有方法
@Pointcut("within(cn.qlq..*)")
public void pc() {
}
2.对象匹配:
1.this
// 匹配AOP对象的目标对象为指定类型的方法,即cn.qlq.service.UserService的AOP代理对象的方法
@Pointcut("target(cn.qlq.service.UserService)")
public void pc() {
}
2.target
// 匹配实现UserService的目标对象,而不是代理对象,这里就是UserService的方法
@Pointcut("target(cn.qlq.service.UserService)")
public void pc() {
}
3.bean
// 匹配注入到spring中所有以Service结尾的类的方法
@Pointcut("bean(*Service)")
public void pc() {
}
3.参数匹配
// 匹配所有以方法名save开头且只有一个String类型参数的方法
@Pointcut("execution(* *..save*(String))")
public void pc() {
}
// 匹配所有只有一个String类型参数的方法
@Pointcut("args(String)")
public void pc() {
}
// 匹配所有以方法名save开头且第一个参数类型为String类型的方法
@Pointcut("args(* *..save*(String,..))")
public void pc() {
}
// 匹配第一个参数类型为String类型的方法
@Pointcut("args(String,..)")
public void pc() {
}
4.注解匹配:
(1)自定义注解:
package cn.qlq.annotationAOP; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; @Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno {
// 定义注解的属性,这不是方法,没有默认值就是必填属性
String name(); // 有默认值,就是可选属性
int value() default 20;
}
(2)方法声明加注解
@MyAnno(name="自定义注解")
@Override
public void save(String userId) throws Exception {
System.out.println("保存用户.....(有参数)");
}
(3)利用注解表达式匹配上面表达式
- 匹配方法的注解
// 匹配方法标有cn.qlq.annotationAOP.MyAnno注解的方法
@Pointcut("@annotation(cn.qlq.annotationAOP.MyAnno)")
public void pc() {
}
- 匹配类的注解
// 匹配标有cn.qlq.annotationAOP.MyAnno注解的类下面的方法,要求annotation的RetentionPolicy为CLASS
@Pointcut("@whithin(cn.qlq.annotationAOP.MyAnno)")
public void pc() {
}
// 匹配标有cn.qlq.annotationAOP.MyAnno注解的类下面的方法,要求annotation的RetentionPolicy为RUNTIME
@Pointcut("@target(cn.qlq.annotationAOP.MyAnno)")
public void pc() {
}
- 匹配参数的注解
// 匹配传入的参数类型标有MyAnno注解的方法
@Pointcut("@args(cn.qlq.annotationAOP.MyAnno)")
public void pc() {
}
5.execution表达式
格式:
有问号的代表可以省略。
演变过程:
public void cn.qlq.service.UserServiceImpl.save() 对指定类型指定返回值的空参方法进行增强
void cn.qlq.service.UserServiceImpl.save() public可以省去,默认public
* cn.qlq.service.UserServiceImpl.save() 对返回类型不做要求,可以对任何返回类型织入
* cn.qlq.service.UserServiceImpl.*() 对返回类型不做要求,对方法名字不做要求
* cn.qlq.service.UserServiceImpl.*(..) 对返回类型不做要求,对方法名字不做要求,对参数也不做要求
* cn.qlq.service.*ServiceImpl.*(..) 对service包下所有以ServiceImpl结尾的类中的任意参数的任意方法增强
* cn.qlq.service.*ServiceImpl.*(..) throws java.sql.SQLException; 对service包下所有以ServiceImpl结尾的类中的任意参数的任意方法且抛出的异常类型是SQLException的方法增强
* cn.qlq.service..*ServiceImpl.*(..) 与上面不同的是对service包的子包也要进行增强(一般不用)
4.五种通知详解:
1.前置通知:@Before
查看源码:
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Before {
String value(); String argNames() default "";
}
第一个value是切点表达式,第二个argName属性不太理解?前置通知可用于参数校验,比如通过下列方式获取参数:
// 匹配传入的参数类型标有MyAnno注解的方法
@Pointcut("@annotation(cn.qlq.annotationAOP.MyAnno)")
public void pc() {
} // 前置通知(下面两种方式均可以)
// @Before("MyAdvice.pc()")
@Before(value = "pc() && args(arg)")
public void before(JoinPoint joinPoint,Object arg) throws Exception {
System.out.println("---------------前置通知开始(注解)~~~~~~~~~~~");
System.out.println("参数是:"+arg.toString());
System.out.println("---------------前置通知结束(注解)~~~~~~~~~~~");
}
需要增强的方法:
@MyAnno(name="自定义注解")
@Override
public boolean save(String userId) throws Exception {
System.out.println("保存用户.....(有参数):"+userId);
return true;
}
测试:
package cn.qlq.test; import javax.annotation.Resource; import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import cn.qlq.service.UserService; //帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用的配置文件
@ContextConfiguration("classpath:cn/qlq/annotationAOP/applicationContext.xml")
public class SpringAnnotationAopTest { @Resource(name="userService")
private UserService us; @Test
public void fun1() throws Exception{
us.save("111");
} }
结果:
---------------前置通知开始(注解)~~~~~~~~~~~
参数是:111
---------------前置通知结束(注解)~~~~~~~~~~~
2.最终通知,方法执行完之后:@After
查看源码:
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface After {
String value(); String argNames() default "";
}
第一个value是切点表达式,第二个argName属性暂时不太理解?
3.后置通知,方法成功执行之后:@AfterReturning
查看源码:
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface AfterReturning {
String value() default ""; String pointcut() default ""; String returning() default ""; String argNames() default "";
}
比上面多了一个returning,是方法的返回值,可以在返回通知中获取方法返回值,然后进行一些处理。例如:
// 后置通知(异常发生后不会调用)
@AfterReturning(value="MyAdvice.pc()",returning = "result")
public void afterRunning(Object result) {
System.out.println(result);//获取方法的返回值
System.out.println("这是后置通知(异常发生后不会调用)。。。。(注解)");
}
4.环绕通知:@Around(一般有环绕通知就不需要其他四种通知)-----------重要
查看源码:
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Around {
String value(); String argNames() default "";
}
环绕通知需要有返回值,而且有异常通知一般不需要其它四种通知
package cn.qlq.annotationAOP; import java.lang.reflect.Method;
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.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component; @Aspect // 表示该类是一个通知类
@Component // 交给spring管理
public class MyAdvice { // 匹配传入的参数类型标有MyAnno注解的方法
@Pointcut("@annotation(cn.qlq.annotationAOP.MyAnno)")
public void pc() {
} // 环绕通知
@Around("MyAdvice.pc()")
public Object around(ProceedingJoinPoint pjp){
System.out.println("----------------环绕通知之前 的部分(相当于前置通知)----------------");
// 获取到类名
String targetName = pjp.getTarget().getClass().getName();
System.out.println("代理的类是:" + targetName);
// 获取到参数
Object[] parameter = pjp.getArgs();
System.out.println("传入的参数是:" + Arrays.toString(parameter));
// 获取到方法签名,进而获得方法
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
System.out.println("增强的方法名字是:" + method.getName());
// 处理一些业务逻辑 // 获取参数类型
Class<?>[] parameterTypes = method.getParameterTypes();
System.out.println("参数类型是:" + parameterTypes.toString()); // 让方法执行
System.out.println("--------------方法开始执行(注解)------------------");
Object proceed=null;
try {
proceed = pjp.proceed();
// 环绕通知之后的业务逻辑部分
System.out.println("----------------环绕通知之后的部分(相当于后置通知AfterReturning)-----------------");
} catch (Throwable e) {
System.out.println("-------------环绕通知的异常部分(相当于异常通知AfterThrowing)--------------------------");
e.printStackTrace();
}finally {
System.out.println("-------------环绕通知的最终部分部分(相当于最终通知After)--------------------------");
} return proceed;
}
}
结果:
----------------环绕通知之前 的部分(相当于前置通知)----------------
代理的类是:cn.qlq.service.UserServiceImpl
传入的参数是:[111]
增强的方法名字是:save
参数类型是:[Ljava.lang.Class;@1548a36c
--------------方法开始执行(注解)------------------
保存用户.....(有参数):111
----------------环绕通知之后的部分(相当于后置通知AfterReturning)-----------------
-------------环绕通知的最终部分部分(相当于最终通知After)--------------------------
如果我们在环绕通知验证完权限之后,如果权限不够我们可以不执行proceed = pjp.proceed();方法,也就是不执行对应的方法。可以灵活的控制方法的执行与否。
5.异常通知: AfterThrowing
查啊看源码:
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface AfterThrowing {
String value() default ""; String pointcut() default ""; String throwing() default ""; String argNames() default "";
}
5.SpringAOP代理的实现原理以及选择代理的方式参考:
http://www.cnblogs.com/qlqwjy/p/7550609.html
6.Spring多个AOP作用于同一目标对象采用的责任链模式
0.简单的类图
1.自己维护逻辑关系的责任链
Handler.java
package cn.qlq.chai; /**
*
* @author: qlq
* @date : 2018年4月8日下午5:09:07
*/
public abstract class Handler { private Handler sucessor; public Handler getSucessor() {
return sucessor;
} public void setSucessor(Handler sucessor) {
this.sucessor = sucessor;
} public void execute(){
handleProcess();
if(sucessor != null){
sucessor.execute();
}
} protected abstract void handleProcess();
}
测试类:
package cn.qlq.chai; /**
*
* @author: qlq
* @date : 2018年4月8日下午5:09:42
*/
public class Client {
static class HandlerA extends Handler{
@Override
protected void handleProcess() {
System.out.println("handle by a");
}
}
static class HandlerB extends Handler{
@Override
protected void handleProcess() {
System.out.println("handle by b");
}
}
static class HandlerC extends Handler{
@Override
protected void handleProcess() {
System.out.println("handle by c");
}
} public static void main(String[] args){
Handler handlerA = new HandlerA();
Handler handlerB = new HandlerB();
Handler handlerC = new HandlerC(); handlerA.setSucessor(handlerB);
handlerB.setSucessor(handlerC); handlerA.execute();
}
}
结果:
handle by a
handle by b
handle by c
2.通过一个集合维护责任链:(类似于递归模式)
ChainHandler.java
package cn.qlq.chai; /**
*
* @author: qlq
*/
public abstract class ChainHandler { public void execute(Chain chain) {
handleProcess();
chain.proceed();
} protected abstract void handleProcess();
}
Chain.java
package cn.qlq.chai; import java.util.List; /**
*
* @author: qlq
*/
public class Chain { private List<ChainHandler> handlers; private int index = 0; public Chain(List<ChainHandler> handlers) {
this.handlers = handlers;
} public void proceed() {
if (index >= handlers.size()) {
return;
}
handlers.get(index++).execute(this);
}
}
测试类:
package cn.qlq.chai; import java.util.Arrays;
import java.util.List; /**
*
* @author: qlq
*/
public class ChainClient {
static class ChainHandlerA extends ChainHandler {
@Override
protected void handleProcess() {
System.out.println("handle by chain a");
}
} static class ChainHandlerB extends ChainHandler {
@Override
protected void handleProcess() {
System.out.println("handle by chain b");
}
} static class ChainHandlerC extends ChainHandler {
@Override
protected void handleProcess() {
System.out.println("handle by chain c");
}
} public static void main(String[] args) {
List<ChainHandler> handlers = Arrays.asList(new ChainHandlerA(), new ChainHandlerB(), new ChainHandlerC());
Chain chain = new Chain(handlers);
chain.proceed();
}
}
结果:
handle by a
handle by b
handle by c
3.Spring的链式调用:(采用上面第二种方式)
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
} Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
关于spring配置总结:
<!-- 0.开启aop,对类代理使用cglib代理 -->
<aop:config proxy-target-class="true"></aop:config>
<!-- 1.开启注解AOP -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!-- 2.开启注解管理aop事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
最后我靠着自己的理解写了一个注解AOP+注解的日志记录功能,参考我的另一篇博客:http://www.cnblogs.com/qlqwjy/p/8747476.html