SpringAOP深入学习

时间:2022-03-13 20:57:24

----------------------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:

SpringAOP深入学习

 表达式:

SpringAOP深入学习

  •  选择器类型

SpringAOP深入学习

  •  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表达式

格式:

SpringAOP深入学习

  有问号的代表可以省略。

演变过程:

    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.简单的类图

SpringAOP深入学习

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