Spring（4）AOP
1、AOP概述
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的
基础上，对我们的已有方法进行增强。
作用：
在程序运行期间，不修改源码对已有方法进行增强。
优势：
减少重复代码、提高开发效率、维护方便
2、动态代理
2.1、动态代理的特点
字节码随用随创建，随用随加载。
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
装饰者模式就是静态代理的一种体现。
2.2、动态代理的两种方式
基于接口的动态代理
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
基于子类的动态代理
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。
2.2.1、基于接口的动态代理
被代理的类
public interface IProducer {
public void saleProduct(float money);
public void afterService(float money);
}
============================================
public class Producer implements IProducer {
public void saleProduct(float money){
System.out.println("售出产品，价格：" + money);
}
public void afterService(float money){
System.out.println("提供售后服务，价格：" + money);
}
}
使用 JDK 官方的 Proxy
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class client {
public static void main(String[] args) {
final Producer producer = new Producer();
//producer.saleProduct(10000f);
/**
* 动态代理：
* 特点：字节码随用随创建，随用随加载
* 资源：在不修改源码的情况下对方法增强
* 分类：
* 基于接口的动态代理
* 基于子类的动态代理
* 基于接口：
* 涉及到类：proxy
* 提供者：JDK官方
* 如何创建代理对象：
* 使用proxy中的newPoxyInstance方法
* 创建代理对象的要求：
* 被代理对象必须有接口，如果没有则不能使用
* newProxyInstance参数：
* classLoader:类加载器
* 用于加载代理对象的字节码，和被代理对象使用相同的类加载器。固定写法
* Class[]：字节码数组
* 让代理对象和被代理对象拥有相同方法。写法固定
* InvocationHandler:用于增强的代码
* 它让我们写如何代理，一般写该接口的实现类，通常情况是匿名内部类，但不是必须的
* 此接口谁用谁写
*/
IProducer proxyProduec = (IProducer)Proxy.newProxyInstance(producer.getClass().getClassLoader()
, producer.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 作用：执行的被代理对象的方法都会经过此方法
* @param proxy 代理对象的引用
* @param method 当前执行的方法
* @param args 被代理对象方法的参数
* @return 被代理对象方法的返回值
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object rtValue = null;
Float money = (Float)args[0];
if("saleProduct".equals(method.getName())){
rtValue = method.invoke(producer, money * 0.8f);
}
return rtValue;
}
});
proxyProduec.saleProduct(10000f);
}
}22.2、基于子类的动态代理
被代理的类
public class Producer {
public void saleProduct(float money){
System.out.println("售出产品，价格：" + money);
}
public void afterService(float money){
System.out.println("提供售后服务，价格：" + money);
}
}
使用 CGLib 的 的 Enhancer
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class client {
public static void main(String[] args) {
final Producer producer = new Producer();
//producer.saleProduct(10000f);
/**
* 动态代理：
* 特点：字节码随用随创建，随用随加载
* 资源：在不修改源码的情况下对方法增强
* 分类：
* 基于接口的动态代理
* 基于子类的动态代理
* 基于接口：
* 涉及到类：Enhancer
* 提供者：第三方
* 如何创建代理对象：
* 使用Enhancer中的create方法
* 创建代理对象的要求：
* 代理类不是最终类
* create参数：
* Class：字节码
* 指定被代理对象的字节码
* Callback：提供增强代码
* 写如何代理，一般是写一个该接口实现类
* 此接口谁用谁写
* 一般写的是该接口的子接口实现类MethodInterceptor
*/
Producer p = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
/**
* 作用：执行的被代理对象的方法都会经过此方法
* @param obj
* @param method
* @param args
* 以上三个参数与基于接口的代理作用相同
* @param proxy 当前方法的代理对象
* @return
* @throws Throwable
*/
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
Object rtValue = null;
Float money = (Float)args[0];
if("saleProduct".equals(method.getName())){
rtValue = method.invoke(producer, money * 0.8f);
}
return rtValue;
}
});
p.saleProduct(10000f);
}
}3、spring中的AOP
3.1、AOP相关术语
Joinpoint( 连接点):
所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
Pointcut( 切入点):
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice( 通知/ 增强):
所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction( 引介):
引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target( 目标对象):
代理的目标对象。
Weaving( 织入):
是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy （代理）:
一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect( 切面):
是切入点和通知（引介）的结合。
3.2、AOP的工作流程
开发阶段（我们做的）
编写核心业务代码，把公用代码抽取出来，制作成通知。在配置文件中，声明切入点与通知间的关系，即切面。
运行阶段（Spring 框架完成的）
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
关于代理的选择
在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。
3.3、基于 XML 的 的 AOP
基于案例描述
案例：在service类的方法执行时加入日志
service类
public interface IAccountService {
/**
* 保存账户
*/
void saveAccount();
/**
* 更新账户
* @param i
* @return
*/
void updateAccount(int i);
/**
* 删除账户
* @return
*/
int deleteAccount();
}
===================================
public class AccountServiceImpl implements IAccountService {
public void saveAccount() {
System.out.println("执行了保存");
}
public void updateAccount(int i) {
System.out.println("执行了更新" + i);
}
public int deleteAccount() {
System.out.println("执行了删除");
return 0;
}
}Logger日志
/**
* 用于记录日志的工具类
*/
public class Logger {
public void printLog(){
System.out.println("Logger类中的printLog执行日志记录。。。");
}
}配置文件
3.3.1、AOP中通知的配置
import org.aspectj.lang.ProceedingJoinPoint;
/**
* 用于记录日志的工具类
*/
public class Logger {
/**
* 前置通知
*/
public void beforePrintLog(){
System.out.println("前置通知Logger类中的beforePrintLog执行日志记录。。。");
}
/**
* 后置通知
*/
public void afterReturningPrintLog(){
System.out.println("后置通知Logger类中的afterReturningPrintLog执行日志记录。。。");
}
/**
* 异常通知
*/
public void afterThrowingPrintLog(){
System.out.println("异常通知Logger类中的afterThrowingPrintLog执行日志记录。。。");
}
/**
* 最终通知
*/
public void afterPrintLog(){
System.out.println("最终通知Logger类中的afterPrintLog执行日志记录。。。");
}
/**
* 环绕通知
* 当配置了环绕通知，切入点方法没有执行，而只通知方法执行了
* 分析：
* 通过对比动态代理中的环绕通知，发现动态代理的环绕通知有明确的切入点方法调用，而现在写的方法没有
* 解决：
* spring框架提供了一个接口：ProceedingJoinPoint 接口，该接口有一个procced()方法，改方法明确了切入点方法调用
* 该接口可作为切入点方法的参数，在实际执行中spring框架会通过该接口的实现类供我们使用
* spring框架中的环绕通知：
* 它是spring框架提供的一种可以在代码中手动控制增强方法何时执行的方式
*/
public Object aroundPrintLog(ProceedingJoinPoint pjp){
Object rtValue = null;
try {
Object[] args = pjp.getArgs();//获取要执行方法的参数
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。前置");
rtValue = pjp.proceed(args);//执行切入点方法
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。后置");
return rtValue;
}catch (Throwable t){
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。异常");
throw new RuntimeException(t);
}finally {
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。最终");
}
}
}配置文件
3.3、基于注解的配置
被代理类
package wf.service.impl;
import org.springframework.stereotype.Service;
import wf.service.IAccountService;
/**
* 账户的服务层实现类
*/
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
public void saveAccount() {
System.out.println("执行了保存");
// int i = 1/0;
}
public void updateAccount(int i) {
System.out.println("执行了更新" + i);
}
public int deleteAccount() {
System.out.println("执行了删除");
return 0;
}
}
切面类
package wf.utils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
/**
* 用于记录日志的工具类
*/
@ComponentScan("wf")
@EnableAspectJAutoProxy
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {
@Pointcut("execution(* wf.service.impl.*.*(..))")
public void pt(){}
/**
* 前置通知
*/
@Before("pt()")
public void beforePrintLog(){
System.out.println("前置通知Logger类中的beforePrintLog执行日志记录。。。");
}
/**
* 后置通知
*/
@AfterReturning("pt()")
public void afterReturningPrintLog(){
System.out.println("后置通知Logger类中的afterReturningPrintLog执行日志记录。。。");
}
/**
* 异常通知
*/
@AfterThrowing("pt()")
public void afterThrowingPrintLog(){
System.out.println("异常通知Logger类中的afterThrowingPrintLog执行日志记录。。。");
}
/**
* 最终通知
*/
@After("pt()")
public void afterPrintLog(){
System.out.println("最终通知Logger类中的afterPrintLog执行日志记录。。。");
}
/**
* 环绕通知
* 当配置了环绕通知，切入点方法没有执行，而只通知方法执行了
* 分析：
* 通过对比动态代理中的环绕通知，发现动态代理的环绕通知有明确的切入点方法调用，而现在写的方法没有
* 解决：
* spring框架提供了一个接口：ProceedingJoinPoint 接口，该接口有一个procced()方法，改方法明确了切入点方法调用
* 该接口可作为切入点方法的参数，在实际执行中spring框架会通过该接口的实现类供我们使用
* spring框架中的环绕通知：
* 它是spring框架提供的一种可以在代码中手动控制增强方法何时执行的方式
*/
@Around("pt()")
public Object aroundPrintLog(ProceedingJoinPoint pjp){
Object rtValue = null;
try {
Object[] args = pjp.getArgs();//获取要执行方法的参数
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。前置");
rtValue = pjp.proceed(args);//执行切入点方法
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。后置");
return rtValue;
}catch (Throwable t){
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。异常");
throw new RuntimeException(t);
}finally {
System.out.println("Logger类中的aroundPrintLog执行日志记录。。。最终");
}
}
}测试类
package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import wf.service.IAccountService;
import wf.utils.Logger;
public class AopTest {
public static void main(String[] args) {
//1.获取容器
// ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
ApplicationContext ac = new AnnotationConfigApplicationContext(Logger.class);
//2.获取容器对象
IAccountService as = ac.getBean("accountService", IAccountService.class);
//3.执行方法
as.saveAccount();
// as.updateAccount(3);
// as.deleteAccount();
}
}