Spring_3 AOP
一、AOP 的相关概念
1、AOP概述
(1) 什么是 AOP
AOP:全称是 Aspect Oriented Programming 即:面向切面编程。
简单的说它就是把我们程序重复的代码抽取出来,在需要执行的时候,使用动态代理的技术,在不修改源码的
基础上,对我们的已有方法进行增强。
(2) AOP 的作用及优势
作用:
在程序运行期间,不修改源码对已有方法进行增强。
优势:
减少重复代码 提高开发效率 维护方便
(3) AOP 的实现方式
(解决重复代码,提取重复代码,在方法执行时加进去)使用动态代理技术
2、AOP 的具体应用
(1) 动态代理回顾
特点:字节码随用随创建,随用随加载。
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好,并完成加载。
装饰者模式就是静态代理的一种体现。
(2) 动态代理常用的有两种方式
基于接口的动态代理
提供者:JDK 官方的 Proxy 类。
如何创建代理对象:使用Proxy类中的newProxyInstance方法
要求:被代理类最少实现一个接口。
基于子类的动态代理
提供者:第三方的 CGLib,如果报 asmxxxx 异常,需要导入 asm.jar。
要求:被代理类不能用 final 修饰的类(最终类)。
(3) 使用 JDK 官方的 Proxy 类创建代理对象
对生产厂家要求的接口
public interface IProducer {
/**
* 销售
* @param money
*/
public void saleProduct(float money);
/**
* 售后
* @param money
*/
public void afterService(float money);
}
实现要求接口的厂家类
public class Producer implements IProducer{
/**
* 销售
* @param money
*/
@Override
public void saleProduct(float money){
System.out.println("销售产品,并拿到钱:"+money);
}
/**
* 售后
* @param money
*/
@Override
public void afterService(float money){
System.out.println("提供售后服务,并拿到钱:"+money);
}
}
模拟一个消费者
/**
* 模拟一个消费者
*/
public class Client {
public static void main(String[] args) {
//new一个厂家
final Producer producer = new Producer();
/*
* 如何创建代理对象:
* 使用Proxy类中的newProxyInstance方法
* 创建代理对象的要求:
* 被代理类最少实现一个接口,如果没有则不能使用
* newProxyInstance方法的参数:
* ClassLoader:类加载器
* 它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
* class[]:字节码数组
它是用于让代理对象和被代理对象具有相同的方法。实现相同的接口。
*
* InvocationHandler:用于提供增强的代码
* 它是让我们写如何代理。我们一般都是些一个该接口的实现类,通常情况下都是匿名内部类,但不是必须的。
* 此接口的实现类都是谁用谁写。
*/
IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
producer.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 作用:执行被代理对象的任何接口方法都会经过该方法
* 方法参数的含义
* @param proxy 代理对象的引用
* @param method 当前执行的方法
* @param args 当前执行方法所需的参数
* @return 和被代理对象方法有相同的返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float)args[0];
//2.判断当前方法是不是销售
if("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money*0.8f);
}
return returnValue;
}
});
proxyProducer.saleProduct(10000f);
}
}
(4) 使用 CGLib 的 的 Enhancer 类创建代理对象
不实现接口,子类的动态代理
/**
* 一个生产者
*/
public class Producer {
//销售
public void saleProduct(float money){
System.out.println("销售产品,并拿到钱:"+money);
}
//售后
public void afterService(float money){
System.out.println("提供售后服务,并拿到钱:"+money);
}
}
/**
* 模拟一个消费者
*/
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
/**
* 基于子类的动态代理:
* 涉及的类:Enhancer
* 提供者:第三方cglib库
* 如何创建代理对象:
* 使用Enhancer类中的create方法
* 创建代理对象的要求:
* 被代理类不能是最终类
* create方法的参数:
* Class:字节码
* 它是用于指定被代理对象的字节码。
*
* Callback:用于提供增强的代码
* 它是让我们写如何代理。我们一般都是些一个该接口的实现类,通常情况下都是匿名内部类,但不是必须的。
* 此接口的实现类都是谁用谁写。
* 我们一般写的都是该接口的子接口实现类:MethodInterceptor
*/
Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {
/**
* 执行被代理对象的任何方法都会经过该方法
* @param proxy
* @param method
* @param args
* 以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
* @param methodProxy :当前执行方法的代理对象
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float)args[0];
//2.判断当前方法是不是销售
if("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money*0.8f);
}
return returnValue;
}
});
cglibProducer.saleProduct(12000f);
}
}
二、Spring 中的 AOP
1、 Spring 中 AOP 的细节
(1) AOP 相关术语
Joinpoint (连接点):
所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
Pointcut (切入点):
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice (通知/增强):
所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型:前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction (引介):
引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target (目标对象):
代理的目标对象。
Weaving (织入):
是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入,而 AspectJ 采用编译期织入和类装载期织入。
Proxy (代理):
一个类被 AOP 织入增强后,就产生一个结果代理类。
Aspect (切面):
是切入点和通知(引介)的结合。
(2)spring AOP要明确的事
a、开发阶段(我们做的)
编写核心业务代码(开发主线):大部分程序员来做,要求熟悉业务需求。
把公用代码抽取出来,制作成通知。(开发阶段最后再做):AOP 编程人员来做。
在配置文件中,声明切入点与通知间的关系,即切面。:AOP 编程人员来做。
b、运行阶段(Spring框架完成的)
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行,使用代理机制,动态创建目标对
象的代理对象,根据通知类别,在代理对象的对应位置,将通知对应的功能织入,完成完整的代码逻辑运行。
(3) 关于代理的选择
在 spring 中,框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。
2、基于 XML 的 AOP 配置
(1) 导入坐标
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.6.RELEASE</version>
</dependency>
<!--解析切入点表达式-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.2</version>
</dependency>
</dependencies>
(2) service包中的IAccountService和其实现类impl.AccountServiceImpl
public interface IAccountService {
/**
* 模拟保存账户
*/
void saveAccount();
/**
* 模拟更新账户
* @param i
*/
void updateAccount(int i);
/**
* 删除账户
* @return
*/
int deleteAccount();
}
public class AccountServiceImpl implements IAccountService {
/**
* 模拟保存账户
*/
@Override
public void saveAccount() {
System.out.println("保存...");
}
/**
* 模拟更新账户
* @param i
*/
@Override
public void updateAccount(int i) {
System.out.println("更新...");
}
/**
* 删除账户
* @return
*/
@Override
public int deleteAccount() {
System.out.println("删除...");
return 0;
}
}
(3) Logger通知类
/**
* 用户记录日志的工具类,它里面提供了公共的代码
*/
public class Logger {
/**
* 前置通知
*/
public void beforePrintLog() {
System.out.println("logger类中的 前置通知");
}
/**
* 后置通知
*/
public void afterReturningPrintLog() {
System.out.println("logger类中的 后置通知");
}
/**
* 异常通知
*/
public void afterThrowingPrintLog() {
System.out.println("logger类中的 异常通知");
}
/**
* 最终通知
*/
public void afterPrintLog() {
System.out.println("logger类中的 最终通知");
}
/**
* 环绕通知
* 问题:
* 当我们配置了环绕通知之后,切入点方法没有执行,而通知方法执行了。
* 分析:
* 通过对比动态代理中的环绕通知代码,发现动态代理的环绕通知有明确的切入点方法调用,而我们的代码中没有。
* 解决:
* Spring框架为我们提供了一个接口:ProceedingJoinPoint。该接口有一个方法proceed(),此方法就相当于明确调用切入点方法。
* 该接口可以作为环绕通知的方法参数,在程序执行时,spring框架会为我们提供该接口的实现类供我们使用。
*
* spring中的环绕通知:
* 它是spring框架为我们提供的一种可以在代码中手动控制(写入的位置)增强方法何时执行的方式。
*/
public Object aroundPrintLog(ProceedingJoinPoint pjp) {
Object rtValue = null;
try {
Object[] args = pjp.getArgs();//得到方法执行所需的参数
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
rtValue = pjp.proceed(args);//明确调用业务层方法(切入点方法)
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
return rtValue;
} catch (Throwable t) {
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
throw new RuntimeException(t);
} finally {
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
}
}
}
(4) bean.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">
<!-- 配置srping的Ioc,把service对象配置进来-->
<bean id="accountService" class="top.zoick.service.impl.AccountServiceImpl"></bean>
<!-- 配置Logger类 -->
<bean id="logger" class="top.zoick.utils.Logger"></bean>
<!--配置AOP-->
<aop:config>
<!--配置切入点表达式,id属性用于指定表达式唯一标识 expression属性用于指定表达式内容
此标签写在aop:aspect标签内部只能当前切面使用。
它还可以写在aop:aspect外面,此时就变成了所有切面可用。注意:由于约束的要求,若要写在外面一定要放在aop:aspect前面
-->
<aop:pointcut id="pt1" expression="execution(* top.zoick.service.impl.*.*(..))"/>
<!--配置切面 -->
<aop:aspect id="logAdvice" ref="logger">
<!-- 配置前置通知: 在切入点方法执行之前执行
<aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>-->
<!-- 配置后置通知:在切入点方法正常执行之后执行,它和异常通知永远只能执行一个
<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>-->
<!-- 配置异常通知:在切入点方法执行产生异常后执行。他和后置通知永远只能执行一个
<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>-->
<!-- 配置最终通知,无论切入点方法是否正常执行它都会在其后面执行
<aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->
<!--配置环绕通知 详细的注释在Logger类中-->
<aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
</aop:aspect>
</aop:config>
</beans>
spring中基于XML的AOP配置步骤
1、把通知Bean也交给spring来管理
2、使用aop:config标签表明开始AOP的配置
3、使用aop:aspect标签表明配置切面
id属性:是给切面提供一个唯一标识
ref属性:是指定通知类bean的Id。
4、在aop:aspect标签的内部使用对应标签来配置通知的类型
aop:before:表示配置前置通知
method属性:用于指定Logger类中哪个方法是前置通知
ponitcut-ref:用于指定切入点的表达式的引用
poinitcut:用于指定切入点表达式
aop:after-returning: 后置通知:在切入点方法正常执行之后执行,它和异常通知永远只能执行一个
aop:after-throwing: 异常通知:在切入点方法执行产生异常后执行。他和后置通知永远只能执行一个
aop:after: 最终通知,无论切入点方法是否正常执行它都会在其后面执行
aop:around: 环绕通知 详细的注释在Logger类中,通常情况下,环绕通知都是独立使用的
切入点表达式相关的注意:
切入点表达式的写法:
关键字:execution(表达式)
表达式:
访问修饰符 返回值 包名.包名.包名...类名.方法名(参数列表)
标准的表达式写法:
public void top.zoick.service.impl.AccountServiceImpl.saveAccount()
访问修饰符可以省略
void top.zoick.service.impl.AccountServiceImpl.saveAccount()
返回值可以使用通配符,表示任意返回值
* top.zoick.service.impl.AccountServiceImpl.saveAccount()
包名可以使用通配符,表示任意包。但是有几级包,就需要写几个*.
* *.*.*.*.AccountServiceImpl.saveAccount())
包名可以使用..表示当前包及其子包
* *..AccountServiceImpl.saveAccount()
类名和方法名都可以使用*来实现通配
* *..*.*()
参数列表:
可以直接写数据类型:
基本类型直接写名称 int
引用类型写包名.类名的方式 java.lang.String
可以使用通配符表示任意类型,但是必须有参数
可以使用..表示有无参数均可,有参数可以是任意类型
全通配写法:
* *..*.*(..)
实际开发中切入点表达式的通常写法:
切到业务层实现类下的所有方法
* top.zoick.service.impl.*.*(..)
<aop:pointcut>配置切入点表达式,id属性用于指定表达式唯一标识 expression属性用于指定表达式内容
此标签写在aop:aspect标签内部只能当前切面使用。
它还可以写在aop:aspect外面,此时就变成了所有切面可用。注意:由于约束的要求,若要写在外面一定要放在aop:aspect前面
<aop:pointcut id="pt1" expression="execution(* top.zoick.service.impl.*.*(..))"/>
(5) 测试
public class AOTest {
public static void main(String[] args) {
//1.获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.获取对象
IAccountService accountService = (IAccountService) ac.getBean("accountService");
//3.执行方法
accountService.saveAccount();
}
}
3、基于注解的 AOP 配置
(1) service类中impl.AccountServiceImpl
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
/**
* 模拟保存账户
*/
@Override
public void saveAccount() {
System.out.println("保存...");
}
/**
* 模拟更新账户
* @param i
*/
@Override
public void updateAccount(int i) {
System.out.println("更新...");
}
/**
* 删除账户
*
* @return
*/
@Override
public int deleteAccount() {
System.out.println("删除...");
return 0;
}
}
(2) utils中的Logger
/**
* 用户记录日志的工具类,它里面提供了公共的代码
*/
@Component("logger")
@Aspect
public class Logger {
@Pointcut("execution(* top.zoick.service.impl.*.*(..))")//切入点表达式
private void pt1(){}
/**
* 前置通知
*/
// @Before("pt1()")
public void beforePrintLog() {
System.out.println("logger类中的 前置通知");
}
/**
* 后置通知
*/
// @AfterReturning("pt1()")
public void afterReturningPrintLog() {
System.out.println("logger类中的 后置通知");
}
/**
* 异常通知
*/
// @AfterThrowing("pt1()")
public void afterThrowingPrintLog() {
System.out.println("logger类中的 异常通知");
}
/**
* 最终通知
*/
// @After("pt1()")
public void afterPrintLog() {
System.out.println("logger类中的 最终通知");
}
@Around("pt1()")
public Object aroundPrintLog(ProceedingJoinPoint pjp) {
Object rtValue = null;
try {
Object[] args = pjp.getArgs();//得到方法执行所需的参数
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
rtValue = pjp.proceed(args);//明确调用业务层方法(切入点方法)
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
return rtValue;
} catch (Throwable t) {
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
throw new RuntimeException(t);
} finally {
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
}
}
}
(3) bean.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:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--注解扫描-->
<context:component-scan base-package="top.zoick"/>
<!--配置spring开启AOP注解-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>