Spring学习——动态代理、AOP
Spring学习——动态代理、AOP
- 一、AOP前奏
- 二、动态代理实现日志功能
- 三、AOP
-
- 3.1 几个专业术语
- 3.2 注解实现AOP的步骤（重点）
- 3.3 注解实现的几个细节
-
- 3.3.1 IOC容器中保存组件的代理类
- 3.3.2 切入表达式的写法（通配符）
- 3.3.3 通知方法的执行顺序
- 3.3.4 JoinPoint获取目标方法的详细信息
- 3.3.5 通过throwing、returning属性来接收结果返回值和异常信息
- 3.3.6 Spring对通知方法的约束
- 3.3.7 使用@Pointcut注解抽取可重用的切入点表达式
- 3.3.8 环绕通知（重点）
- 3.3.9 多切面运行顺序
- 3.3.10 完全使用注解开发
- 3.4 以XML方式配置AOP
以下分析来自Spring4
一、AOP前奏
AOP：（Aspect Oriented Programming）面向切面编程，利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
OOP：（Object Oriented Programming）面向对象编程
面向切面编程：基于OOP基础之上的新编程思想；指在程序运行期间，将某段代码动态的切入到指定的方法的指定位置进行运行的这种编程方式，成为面向切面编程
二、动态代理实现日志功能
问题的引入：计算器运行计算方法时进行日志记录
方法一：直接编写在方法内部【不推荐】，修改维护麻烦，代码耦合
方法二：使用动态代理实现日志功能
动态代理的实现过程：
-
定义一个Calculator接口，声明加减乘除方法
-
定义一个MyCalculator类实现Calculator接口，完成方法体
-
定义一个生成代理对象的类CalculatorProxy，通过调用Proxy的newProxyInstance方法获取代理对象
-
重写InvocationHandler的invoke方法，在执行目标方法前后，添加相应的日志输出，也可以处理异常信息
newProxyInstance 方法的三个参数：
第一参数：类加载器
第二参数：增强方法所在的类，这个类实现的接口，支持多个接口
第三参数：实现这个接口 InvocationHandler，创建代理对象，写增强的部分
Calculator接口：
public interface Calculator {
//加减乘除方法
public int add(int i, int j);
public int subtract(int i, int j);
public int multiply(int i, int j);
public int divide(int i, int j);
}
MyCalculator类：
public class MyCalculator implements Calculator {
@Override
public int add(int i, int j) {
return i + j;
}
@Override
public int subtract(int i, int j) {
return i - j;
}
@Override
public int multiply(int i, int j) {
return i * j;
}
@Override
public int divide(int i, int j) {
return i / j;
}
}
日志工具类LogUtils：
public class LogUtils {
//执行前
public static void before(Method method,Object... args) {
System.out.println("【"+method.getName()+"】方法开始执行了，用的参数列表是【"+ Arrays.asList(args)+"】");
}
//执行后
public static void after(Method method,Object result) {
System.out.println("【"+method.getName()+"】方法执行完成了，计算结果是【"+ result+"】");
}
//出现异常
public static void exception(Method method,Exception e) {
System.out.println("【"+method.getName()+"】方法出现异常了,异常信息是："+e.getCause());
}
//方法结束
public static void end(Method method) {
System.out.println("【"+method.getName()+"】方法最终结束了");
}
}
生成代理对象的类CalculatorProxy：
public class CalculatorProxy {
/**
* 为传入的参数对象创建一个动态代理对象
*/
public static Calculator getProxy(final Calculator calculator) {
//方法执行器。帮我们目标对象执行目标方法
InvocationHandler h = new InvocationHandler() {
/**
* Object proxy：代理对象；给jdk使用，任何时候都不要动这个对象
* Method method：当前将要执行的目标对象的方法
* Object[] args：这个方法调用时外界传入的参数值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 利用反射执行目标方法
//目标方法执行后的返回值
//System.out.println("这是动态代理将要帮你执行方法...");
Object result = null;
try {
LogUtils.logStart(method, args);
result = method.invoke(calculator, args);
LogUtils.logReturn(method, result);
} catch (Exception e) {
LogUtils.logException(method,e);
}finally{
LogUtils.logEnd(method);
}
//返回值必须返回出去外界才能拿到真正执行后的返回值
return result;
}
};
Class<?>[] interfaces = calculator.getClass().getInterfaces();
ClassLoader loader = calculator.getClass().getClassLoader();
//Proxy为目标对象创建代理对象；
Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
return (Calculator) proxy;
}
}
结果：
【add】方法开始执行了，用的参数列表是【[1, 2]】
动态代理要帮你执行方法！
【add】方法执行完成了，计算结果是【3】
【add】方法最终结束了
【divide】方法开始执行了，用的参数列表是【[2, 0]】
动态代理要帮你执行方法！
【divide】方法出现异常了,异常信息是：java.lang.ArithmeticException: / by zero
【divide】方法最终结束了
动态代理的问题：
1、代码复杂
2、jdk默认的动态代理，如果目标对象没有实现任何接口，是无法为其创建代理对象的
所以就引出了Spring的动态代理：Spring动态代理—>Spring实现AOP功能；底层就是动态代理
1、可以利用Spring一句代码都不写的去创建动态代理；实现简单
2、没有强制要求必须实现接口
三、AOP
AOP：(Aspect Oriented Programming) 面向切面编程，将某段代码动态的切入到指定方法的指定位置(方法的开始、结束、异常…)。
使用场景：
1、AOP加日志保存到数据库中
2、AOP做权限验证
3、AOP做安全检查
4、AOP做事务控制
3.1 几个专业术语
- 连接点(Joinpoint)：类里面那些方法可以被增强，这些方法称为连接点
- 切入点(pointcut)：实际被真正增强的方法，称为切入点
- 通知(Advice)：实际增强的逻辑部分称为通知（增强）
前置通知
后置通知
环绕通知
异常通知
最终通知 finally - 切面(Aspect)：把通知应用到切入点过程
- 横切关注点：从每个方法中抽取出来的同一类非核心业务。
- 目标(Target)：被通知的对象
- 代理(Proxy)：向目标对象应用通知之后创建的代理对象
3.2 注解实现AOP的步骤（重点）
Spring 框架一般都是基于 AspectJ 实现 AOP 操作。AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作
实现步骤：
-
导包
spring-aop-4.0.0.RELEASE spring-beans-4.0.0.RELEASE spring-context-4.0.0.RELEASE spring-core-4.0.0.RELEASE spring-expression-4.0.0.RELEASE spring-aspects-5.2.3.RELEASE.jar基础包 加强版的面向切面编程（即使目标对象没有实现任何接口也能创建动态代理） com.springsource.org.aspectj.weaver-1.6.8.RELEASE com.springsource.org.aopalliance-1.0.0 com.springsource.net.sf.cglib-2.2.0 -
在 spring 配置文件中，开启注解扫描
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <context:component-scan base-package="com.zb.aopanno">context:component-scan> beans> -
使用注解创建User和切面对象
//被增强的类 @Component public class User { public void add() { System.out.println("add......."); } } @Component public class UserProxy { } -
告诉Spring哪个是切面类，在类上注解
@Aspect//增强的类 @Component @Aspect //生成代理对象 public class UserProxy { } -
配置文件中开启基于注解的AOP功能
-
配置不同类型的通知
在注解中写切入点表达式：execution(访问权限符 返回值类型 方法全类名(参数表))
通知注解： @Before：在目标方法之前运行；前置通知 @After：在目标方法之后运行；后置通知 @AfterReturning：在目标方法正常返回之后；返回通知 @AfterThrowing：在目标方法抛出异常之后；异常通知 @Around：环绕通知@Component @Aspect //生成代理对象 public class UserProxy { /** * 告诉Spring每个方法都什么时候运行； * try{ * @Before * method.invoke(obj,args); * @AfterReturning * }catch(e){ * @AfterThrowing * }finally{ * @After * } * 5个通知注解，告诉Spring，切面类里面的每一个方法，都是何时何地运行 * @Before：在目标方法之前运行； 前置通知 * @After：在目标方法结束之后 后置通知 * @AfterReturning：在目标方法正常返回之后 返回通知 * @AfterThrowing：在目标方法抛出异常之后运行 异常通知 * @Around：环绕 */ //前置通知 //@Before 注解表示作为前置通知 //execution(访问权限符 返回值类型 方法签名)，在注解中写切入点表达式 @Before(value = "execution(* com.zb.aopanno.User.add(..))") public void before() { System.out.println("before........."); } //后置通知（返回通知） @AfterReturning(value = "execution(* com.zb.aopanno.User.add(..))") public void afterReturning() { System.out.println("afterReturning........."); } //最终通知 @After(value = "execution(* com.zb.aopanno.User.add(..))") public void after() { System.out.println("after........."); } //异常通知 @AfterThrowing(value = "execution(* com.zb.aopanno.User.add(..))") public void afterThrowing() { System.out.println("afterThrowing........."); } //环绕通知 @Around(value = "execution(* com.zb.aopanno.User.add(..))") public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { System.out.println("环绕之前........."); //被增强的方法执行 proceedingJoinPoint.proceed(); System.out.println("环绕之后........."); } } -
测试
@Test public void testAopAnno() { ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); User user = context.getBean("user", User.class); user.add(); }执行结果：
基于注解的AOP步骤总结
3.3 注解实现的几个细节
3.3.1 IOC容器中保存组件的代理类
-
IOC容器中保存的是组件的代理对象。所以当组件实现了接口时，ioc.getBean()中使用的接口类型，也可以用id名
@Test public void test01(){ //AOP底层就是动态代理，容器中保存的组件是他的代理对象：$Proxy23， //所有用MyMathCalculator.class获取不到，因为他本身不是这个类型，他是其的代理对象 //使用接口类型获取组件的代理对象 Calculator bean = ioc.getBean(Calculator.class); System.out.println(bean.toString());//com.zb.impl.MyMathCalculator@dd8ba08 System.out.println(bean.getClass().getName());//com.sun.proxy.$Proxy12 //使用id名获取组件的代理对象 Calculator bean1 = (Calculator)ioc.getBean("myMathCalculator"); System.out.println(bean1.toString());//com.zb.impl.MyMathCalculator@dd8ba08 System.out.println(bean1.getClass().getName());//com.sun.proxy.$Proxy12 } -
补充：若该对象没有接口，则使用本类类型
当目标类没有实现接口时，则spring将自动使用cglib帮我们创建代理对象
@Test public void test01(){ MyMathCalculator bean2 = ioc.getBean(MyMathCalculator.class); bean2.add(1, 2); //com.zb.impl.MyMathCalculator@22fcf7ab System.out.println(bean2); //class com.zb.impl.MyMathCalculator$$EnhancerByCGLIB$$f7c49fce //cglib帮我们创建好的代理对象 System.out.println(bean2.getClass()); //如果实现了接口就转成接口类型，否则就转成类类型 MyMathCalculator bean1 = (MyMathCalculator)ioc.getBean("myMathCalculator"); System.out.println(bean1.toString());//com.zb.impl.MyMathCalculator@22fcf7ab System.out.println(bean1.getClass().getName());//com.zb.impl.MyMathCalculator$$EnhancerByCGLIB$$f7c49fce }
3.3.2 切入表达式的写法（通配符）
通配符：
* :
1）匹配一个或者多个字符:execution(public int com.atguigu.impl.MyMath*r.*(int, int))
2）匹配任意一个参数：第一个是int类型，第二个参数任意类型；（匹配两个参数）
execution(public int com.atguigu.impl.MyMath*.*(int, *))
3）只能匹配一层路径
execution(public int com.zb.*.MyMathCalculator.*(int, int))
4）权限位置*不能；权限位置不写就行；public【可选的】
.. :
1）匹配任意多个参数，任意类型参数
execution(public int com.zb.impl.MyMathCalculator.*(..))
2）匹配任意多层路径:
execution(public int com.atguigu..MyMath*.*(..));
记住两种:
最精确的 execution(public int com.achang.impl.MyMathCalculator.add(int,int))
最模糊的 execution(* .(…)):千万别写
在AspectJ中，切入点表达式可以通过 “&&”、“||”、“!”等操作符结合起来。
execution (* *.add(int,..)) || execution(* *.sub(int,..))
3.3.3 通知方法的执行顺序
try{
@Before
method.invoke(obj,args);
@AfterReturning
}catch(e){
@AfterThrowing
}finally{
@After
}
正常执行情况：@Before(前置通知)—>@After(后置通知)—>@AfterReturning(正常返回)
异常执行情况：@Before(前置通知)—>@After(后置通知)—>@AfterThrowing(方法异常)
对于Spring4的执行顺序：
对于spring5的执行顺序（重点）：
3.3.4 JoinPoint获取目标方法的详细信息
JoinPoint joinPoint：封装了当前目标方法的详细信息
//JoinPoint joinPoint：封装了当前目标方法的详细信息
@Before("execution(public int com.zb.*.MyMathCalculator.*(int, int))")
public static void logStart(JoinPoint joinPoint){
//获取目标方法运行时使用的参数
Object[] args = joinPoint.getArgs();
//获取到方法签名
Signature signature = joinPoint.getSignature();
String name = signature.getName();
System.out.println("【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
}
3.3.5 通过throwing、returning属性来接收结果返回值和异常信息
//returning="result",告诉Spring这个result用来接收返回值
@AfterReturning(value="execution(public int com.zb.impl.MyMathCalculator.*(int, int))",returning="result")
public static void logReturn(JoinPoint joinPoint,Object result){
String name = joinPoint.getSignature().getName();
System.out.println("【"+name+"】方法正常执行完成，计算结果是："+result);
}
//throwing="exception",告诉Spring哪个参数用来接收异常
@AfterThrowing(value="execution(public int com.zb.impl.MyMathCalculator.*(..))",throwing="exception")
public static void logException(JoinPoint joinPoint,Exception exception) {
String name = joinPoint.getSignature().getName();
System.out.println("【"+name+"】方法执行出现异常了，异常信息是："+exception+"；这个异常已经通知测试小组进行排查");
}
3.3.6 Spring对通知方法的约束
-
Spring对通知方法的要求不严格：修改返回值和去掉静态static都照样运行
-
但参数表上的每一个参数，Spring都得知道是什么
3.3.7 使用@Pointcut注解抽取可重用的切入点表达式
- 在编写AspectJ切面时，可以直接在通知注解中书写切入点表达式。但同一个切点表达式可能会在多个通知中重复出现。
- 在AspectJ切面中，可以通过@Pointcut注解将一个切入点声明成简单的方法。切入点的方法体通常是空的，因为将切入点定义与应用程序逻辑混在一起是不合理的。
- 切入点方法的访问控制符同时也控制着这个切入点的可见性。如果切入点要在多个切面中共用，最好将它们集中在一个公共的类中。在这种情况下，它们必须被声明为public。在引入这个切入点时，必须将类名也包括在内。如果类没有与这个切面放在同一个包中，还必须包含包名。
- 其他通知可以通过方法名称引入该切入点
3.3.8 环绕通知（重点）
- 环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。
- 对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是 JoinPoint的子接口，允许控制何时执行，是否执行连接点。
- 在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。相当于动态代理中的method.invoke(obj,args)
- 注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用 joinPoint.proceed();的返回值，否则会出现空指针异常。
环绕通知和其他通知执行顺序：
切面类：
@Component
@Aspect
public class LogUtils {
@Pointcut("execution(public int com.zb.*.MyMathCalculator.*(int, int))")
public void hahaMyPoint(){
}
//想在执行目标方法之前运行；写切入点表达式
//execution(访问权限符 返回值类型 方法签名)，在注解中写切入点表达式
@Before("hahaMyPoint()")
public static void logStart(JoinPoint joinPoint){
//获取目标方法运行时使用的参数
Object[] args = joinPoint.getArgs();
//获取到方法签名
Signature signature = joinPoint.getSignature();
String name = signature.getName();
System.out.println("【"+name+"】方法开始执行，用的参数列表【"+Arrays.asList(args)+"】");
}
//想在目标方法正常执行完成之后执行
//returning="result",告诉Spring这个result用来接收返回值
@AfterReturning(value="hahaMyPoint()",returning="result")
private void logReturn(JoinPoint joinPoint,Object result){
String name = joinPoint.getSignature().getName();
System.out.println("【"+name+"】方法正常执行完成，计算结果是："+result);
}
//想在目标方法出现异常的时候执行
//throwing="exception",告诉Spring哪个参数用来接收异常
@AfterThrowing(value="hahaMyPoint()",throwing="exception")
public static int logException(JoinPoint joinPoint,Exception exception) {
String name = joinPoint.getSignature().getName();
System.out.println("【"+name+"】方法执行出现异常了，异常信息是："+exception+"；这个异常已经通知测试小组进行排查");
return 0;
}
//想在目标方法结束的时候执行
@After("hahaMyPoint()")
public static void logEnd(JoinPoint joinPoint) {
String name = joinPoint.getSignature().getName();
System.out.println("【"+name+"】方法最终结束了");
}
/**
*{
* try{
* 环绕前置
* 环绕执行：目标方法执行
* 环绕返回
* }catch(){
* 环绕出现异常
* }finally{
* 环绕后置
* }
*}
*新的顺序：
* （环绕前置---普通前置）----目标方法执行----环绕正常返回/出现异常-----环绕后置----普通后置---普通返回或者异常
*/
@Around("hahaMyPoint()")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
String name = pjp.getSignature().getName();
Object[] args = pjp.getArgs();
Object proceed = null;
try {
//@Before
System.out.println("【环绕前置通知】【"+name+"方法开始】");
//就是利用反射调用目标方法即可，就是method.invoke(obj,args)
proceed = pjp.proceed(args);
//@AfterReturing
System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
} catch (Exception e) {
//@AfterThrowing
System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
//为了让外界能知道这个异常，这个异常一定抛出去
throw new RuntimeException(e);
} finally{
//@After
System.out.println("【环绕后置通知】【"+name+"】方法结束");
}
//反射调用后的返回值也一定返回出去
return proceed;
}
}
结果：
执行顺序：
(环绕前置 —> 普通前置)（环绕调用目标方法后普通前置才能感受到，才会调用） —> 目标方法执行 —> 环绕正常返回/出现异常 —> 环绕后置 —> 普通后置 —> 普通返回或者异常
3.3.9 多切面运行顺序
-
切面的优先级可以通过实现Ordered接口或利用@Order注解指定。
-
实现Ordered接口，getOrder()方法的返回值越小，优先级越高。
-
若使用@Order注解，序号出现在注解中
@Order(2) //使用@Order改变切面顺序；数值越小优先级越高 public class LogUtils {} @Order(1) public class ValidateAspect {}
多切面运行顺序类型于队列（先进后出）
3.3.10 完全使用注解开发
//创建配置类，不需要创建 xml 配置文件
@Configuration
@ComponentScan(basePackages = {"com.atguigu"})//开启注解扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启 Aspect 生成代理对象
public class ConfigAop {
}
3.4 以XML方式配置AOP
-
概述
除了使用AspectJ注解声明切面，Spring也支持在bean配置文件中声明切面。这种声明是通过aop名称空间中的XML元素完成的。
正常情况下，基于注解的声明要优先于基于XML的声明。通过AspectJ注解，切面可以与AspectJ兼容，而基于XML的配置则是Spring专有的。由于AspectJ得到越来越多的 AOP框架支持，所以以注解风格编写的切面将会有更多重用的机会。 -
配置细节
在bean配置文件中，所有的Spring AOP配置都必须定义在
-
声明切入点
切入点使用
切入点必须定义在
定义在
定义在
基于XML的AOP配置不允许在切入点表达式中用名称引用其他切入点
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
<bean id="MyMathCalculator" class="com.zb.impl.MyMathCalculator">bean>
<bean id="LogUtils" class="com.zb.utils.LogUtils">bean>
<bean id="ValidateAspect" class="com.zb.utils.ValidateAspect">bean>
<aop:config>
<aop:pointcut expression="execution(* com.zb.impl.*.*(..))" id="globalPoint"/>
<aop:aspect ref="LogUtils">
<aop:pointcut expression="execution(* com.zb.impl.*.*(..))" id="mypoint"/>
<aop:before method="logStart" pointcut="execution(* com.zb.impl.*.*(..))"/>
<aop:after-returning method="logReturn" pointcut-ref="mypoint" returning="result"/>
<aop:after-throwing method="logException" pointcut-ref="mypoint" throwing="exception"/>
<aop:after method="logEnd" pointcut-ref="mypoint"/>
<aop:around method="myAround" pointcut="execution(* com.zb.impl.*.*(..))"/>
aop:aspect>
<aop:aspect ref="ValidateAspect">
<aop:before method="logStart" pointcut="execution(* com.zb.impl.*.*(..))"/>
<aop:after-returning method="logReturn" pointcut-ref="globalPoint" returning="result"/>
<aop:after-throwing method="logException" pointcut-ref="globalPoint" throwing="exception"/>
<aop:after method="logEnd" pointcut-ref="globalPoint"/>
aop:aspect>
aop:config>
beans>
注解配置：快速方便
XML配置：功能完善
总结：重要的内容用XML配置，不重要的使用注解