Spring AOP设计模式
时间:2023-08-04 15:54:28
Spring AOP
- 代理模式
- 代理模式在 Java 开发是一种常见的设计模式。设计的目的是在服务和客户之间插入其他设计模式
- 功能,插入功能对调整者透明,起伪装控制作用。比如租房的例子:租客、中介、房东。
- 在代理模式中,即:客户类和代理类 、委托类(被代理类)。
- 为一个对象(委托类)提供一个代理(代理类)来控制对该对象的访问。委托类和代理类有
- ?一个共同的类别或连接。代理将预处理和过滤请求,并将请求分配给指定的对象。
- ?活常代理情况:
- 租房中介、婚庆公司等
- 代理模式的两个设计原则:
- 代理类 与 委托类 相似的是(共同)
- 代理增强委托类
- 常?的代理模式:
- 静态代理
- 动态代理
- 静态代理
- 对象提供固定的代理,以控制对象的访问。 代理和委托有共同的类别或
- ?连接,这样在任何委托对象的地方都可以替换代理对象。代理负责要求的预处理、过滤、
- 将请求分配给委托处理和委托执行后续处理。
- 3.1. 代理的三要素
- a、共同的是(结婚) - 接?
- b、?标准(新) - 实现?为
- c、代理(婚庆公司) - 实现?为 增强标准对象为
- 3.2. 静态代理的特点
- 1.固定标准
- 2.在程序执行前获得标准
- 3.代理对象将增强标准对象
- 4.可能有多个代理 引起"类爆炸"(缺点)
- 3.3. 实现静态代理
- 3.3.1. 定义为(共同) 定义接?
- 3.3.2. ?标对象(实现为)
- 3.3.3. 代理对象(实现或增强标准对象)
定义?为
public interface Marry {
public void toMarry();
静态代理 ——> ?标对象
public class You implements Marry {
// 实现?为
@Override
public void toMarry() {
System.out.println(我要结婚了…”);
}
}
/**
- 静态代理 ——> 代理对象
- */
- public class MarryCompanyProxy implements Marry {
- // ?标对象
- private Marry marry;
- // 标对象通过结构器传输
- public MarryCompanyProxy(Marry marry) {
- this.marry = marry;
- }
- // 实现?为
- @Override
- public void toMarry() {
- // 增强?为
- before();
// 执??标对象中的?法
marry.toMarry();
// 增强?为
3.3.4. 标对象的功能通过代理对象实现
静态代理是固定的,例如dao层有20个dao类,如果要将法律的访问权限进入代理,这个
需要创建20个静态代理,引起类爆炸,法满产生需求,从而催促动态代理的思想。
4. 动态代理
与静态代理相比,动态代理在创建代理对象时更加灵活。在程序运输过程中,动态代理字节码是由
Java动态生产的反射机制。根据需要,通过程序运输期的反射机制,动态为标准对象创建代理
大象,程序员需要编写它的源代码。动态代理不仅简化了编程,还提到了软件系统的可扩展性
性,因为反射机制可以成为任何类型的动态代理。代理可以代理多种方法,即满产所需
同时达到代码通的。
动态代理的两种实现:
- JDK 动态代理
- CGLIB动态代理
- after();
- }
- /**
- 增强?为
- /
- private void after() {
- System.out.println(新婚快乐,早?
- }
- /*
- 增强?为
- */
- private void before() {
- System.out.println(场地正在布置中…”);
- }
- }
- // ?标对象
- You you = new You();
- // 同时代理同时传真实
- MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
- // 通过代理对象调整标对象中的法律
- marryCompanyProxy.toMarry();
- 4.1. 动态代理的特点
- ?标准对象不固定
- 在程序执行时动态创建标对象
- 代理对象将增强标准对象
- 4.2. JDK动态代理
- 注:JDK动态代理的标对象必须连接才能实现
- 4.2.1. newProxyInstance
- Proxy类:
- Proxy类是专门完成代理的操作类,可以通过这种类型动态实现,提供
- 以下操作方法:
- 4.2.2. 获取代理对象
- /*
- 返回指定代理类实例法律调整分配到指定的调整处理程序。 (返回代理对象)
- loader:?个ClassLoader对象,定义哪一个ClassLoader对象对代理对象加载
- interfaces:?个Interface对象的数组意味着我将为我需要代理的对象提供什么组?
- ?,如果 我给它提供了一个组接,然后代理对象声称实现了这个组接(多态)
- 就能调?这 组接中的法
- h:?个InvocationHandler代理实例调整处理程序实现的连接。每个代理实例都有
- ?个 相关的调整处理程序。代理实例调法时,将法律调整进入编码,并将其分配给其调整
- 处理程序 的 invoke ?法(传?InvocationHandler连接的类)
- /
- public static Object newProxyInstance(ClassLoader loader,
- Class>[] interfaces,
- InvocationHandler h)
- public class JdkHandler implements InvocationHandler {
- // ?标对象
- private Object target; // ?标准对象的类型不固定,创建时动态
- // 标对象通过构造器赋值
- public JdkHandler(Object target) {
- this.target = target;
- }
- /*
- 1.调整标对象法(返回)Object)
- 2.增强标的对象
- @param proxy 调整法律代理实例
- @param method ?标对象法
- 4.2.3. 标对象的功能通过代理对象实现
- @param args ?法形参与标对象
- @return
- @throws Throwable
- /
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws
- Throwable {
- // 增强?为
- System.out.println(“?法前执?");
- // 调整标对象法(返回Object)
- Object result = method.invoke(target,args);
- // 增强?为
- System.out.println("?法后执?”);
- return result;
- }
- /*
- 获取代理对象
- public static Object newProxyInstance(ClassLoader loader,
- Class>[] interfaces,
- InvocationHandler h)
- loader:类加载器
- interfaces:接?数组
- h:InvocationHandler接? (传?InvocationHandler实现实现类)
- @return
- */
- public Object getProxy() {
- return
- Proxy.newProxInstance(this.getClass().getClassLoader(),target.getClass().getI
- nterfaces(),this);
- }
- }
- 注:JDK的动态代理依靠接⼝实现,如果有些类并没有接⼝实现,则不能使⽤JDK代理。
- 4.3. CGLIB 动态代理
- JDK的动态代理机制只能代理实现了接⼝的类,⽽不能实现接⼝的类就不能使⽤JDK的动态代理,
- cglib是针对类来实现代理的,它的原理是对指定的⽬标类⽣成⼀个⼦类,并覆盖其中⽅法实现增强,但
- 因为采⽤的是继承,所以不能对final修饰的类进⾏代理。
- 4.3.1. 添加依赖
- 在pom.xml⽂件中引⼊cglib的相关依赖
- 4.3.2. 定义类
- 实现MethodInterceptor接⼝
- // ⽬标对象
- You you = new You();
- // 获取代理对象
- JdkHandler jdkHandler = new JdkHandler(you);
- Marry marry = (Marry) jdkHandler.getProxy();
- // 通过代理对象调⽤⽬标对象中的⽅法
- marry.toMarry();
- 问:Java动态代理类中的invoke是怎么调⽤的?
- 答:在⽣成的动态代理类 P r o x y 0. c l a s s 中 , 构 造 ⽅ 法 调 ⽤ 了 ⽗ 类 P r o x y . c l a s s 的 构 造 ⽅ 法 , 给 成 员 变 量 i n v o c a t i o n H a n d l e r 赋 值 , Proxy0.class中,构造⽅法调⽤了⽗类Proxy.class的构造⽅法,给成员变 量invocationHandler赋值, Proxy0.class中,构造⽅法调⽤了⽗类Proxy.class的构造⽅法,给成员变量invocationHandler赋值,Proxy0.class的static模块中创建了被代理类的⽅法,调⽤相应⽅法
- 时⽅法体中调⽤了⽗类中的成员变量InvocationHandler的invoke()⽅法。
cglib cglib 2.2.2 public class CglibInterceptor implements MethodInterceptor { // ⽬标对象 private Object target; // 通过构造器传⼊⽬标对象
4.3.3. 调⽤⽅法 public CglibInterceptor(Object target) { this.target = target; } /** * 获取代理对象 * @return */ public Object getProxy() { // 通过Enhancer对象的create()⽅法可以⽣成⼀个类,⽤于⽣成代理对象 Enhancer enhancer = new Enhancer(); // 设置⽗类 (将⽬标类作为其⽗类) enhancer.setSuperclass(target.getClass()); // 设置拦截器 回调对象为本身对象 enhancer.setCallback(this); // ⽣成⼀个代理类对象,并返回 return enhancer.create(); } /** * 拦截器 *
1、⽬标对象的⽅法调⽤ *
2、增强⾏为 * @param object 由CGLib动态⽣成的代理类实例 * @param method 实体类所调⽤的被代理的⽅法引⽤ * @param objects 参数值列表 * @param methodProxy ⽣成的代理类对⽅法的代理引⽤ * @return * @throws Throwable */ @Override public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { // 增强⾏为 System.out.println("==============⽅法前执⾏"); // 调⽤⽬标对象的⽅法(返回Object) Object result = methodProxy.invoke(target,objects); // 增强⾏为 System.out.println("⽅法后执⾏=============="); return result; } }
4.4. JDK代理与CGLIB代理的区别 JDK动态代理实现接⼝,Cglib动态代理继承思想 JDK动态代理(⽬标对象存在接⼝时)执⾏效率⾼于Ciglib 如果⽬标对象有接⼝实现,选择JDK代理,如果没有接⼝实现选择Cglib代理
5. Spring AOP
5.1. ⽇志处理带来的问题 我们有⼀个Pay(接⼝) 然后两个实现类DollarPay和RmbPay,都需要重写pay()⽅法, 这时我们需要对 pay⽅法进⾏性能监控,⽇志的添加等等怎么做?
5.1.1. 最容易想到的⽅法 对每个字符⽅法均做⽇志代码的编写处理,如下⾯⽅式 缺点: 代码重复太多, 添加的⽇志代码耦合度太⾼(如果需要更改⽇志记录代码功能需求,类中⽅法需 要全部改动,⼯程量浩⼤)
5.1.2. 使⽤装饰器模式 /代理模式改进解决⽅案 装饰器模式:动态地给⼀个对象添加⼀些额外的职责。 代理模式:以上刚讲过。于是得出以下结构: // ⽬标对象 You you = new You(); CglibInterceptor cglibInterceptor = new CglibInterceptor(you); Marry marry = (Marry) cglibInterceptor.getProxy(); marry.toMarry(); User user = new User(); CglibInterceptor cglibInterceptor = new CglibInterceptor(user); User u = (User) cglibInterceptor.getProxy(); u.test(); 仔细考虑过后发现虽然对原有内部代码没有进⾏改动,对于每个类做⽇志处理,并引⽤⽬标类,但是 如果待添加⽇志的业务类的数量很多,此时⼿动为每个业务类实现⼀个装饰器或创建对应的代理类,同 时代码的耦合度也加⼤,需求⼀旦改变,改动的⼯程量也是可想⽽知的。 有没有更好的解决⽅案,只要写⼀次代码,对想要添加⽇志记录的地⽅能够实现代码的复⽤,达到松耦 合的同时,⼜能够完美完成功能? 答案是肯定的,存在这样的技术,aop已经对其提供了完美的实现!
5.2. 什么是AOP? Aspect Oriented Programing ⾯向切⾯编程,相⽐较 oop ⾯向对象编程来说,Aop关注的不再是程 序代码中某个类,某些⽅法,⽽aop考虑的更多的是⼀种⾯到⾯的切⼊,即层与层之间的⼀种切⼊,所 以称之为切⾯。联想⼤家吃的汉堡(中间夹⾁)。那么aop是怎么做到拦截整个⾯的功能呢?考虑前⾯ 学到的servlet filter /* 的配置 ,实际上也是aop 的实现。
5.3. AOP能做什么? AOP主要应⽤于⽇志记录,性能统计,安全控制,事务处理等⽅⾯,实现公共功能性的重复使⽤。
5.4. AOP的特点
1. 降低模块与模块之间的耦合度,提⾼业务代码的聚合度。(⾼内聚低耦合)
2. 提⾼了代码的复⽤性。
3. 提⾼系统的扩展性。(⾼版本兼容低版本)
4. 可以在不影响原有的功能基础上添加新的功能 5.4.1. AOP的底层实现 动态代理(JDK + CGLIB)
5.5. AOP基本概念
5.5.1. Joinpoint(连接点) 被拦截到的每个点,spring中指被拦截到的每⼀个⽅法,spring aop⼀个连接点即代表⼀个⽅法的执 ⾏。
5.5.2. Pointcut(切⼊点) 对连接点进⾏拦截的定义(匹配规则定义 规定拦截哪些⽅法,对哪些⽅法进⾏处理),spring 有专 ⻔的表达式语⾔定义。
5.5.3. Advice(通知) 拦截到每⼀个连接点即(每⼀个⽅法)后所要做的操作 1. 前置通知 (前置增强)— before() 执⾏⽅法前通知 2. 返回通知(返回增强)— afterReturn ⽅法正常结束返回后的通知 3. 异常抛出通知(异常抛出增强)— afetrThrow() 4. 最终通知 — after ⽆论⽅法是否发⽣异常,均会执⾏该通知。
5. 环绕通知 — around 包围⼀个连接点(join point)的通知,如⽅法调⽤。这是最强⼤的⼀种通知 类型。 环绕通知可以在⽅法调⽤前后完成⾃定义的⾏为。它也会选择是否继续执⾏连接点或直接 返回它们⾃⼰的返回值或抛出异常来结束执⾏。
5.5.4. Aspect(切⾯) 切⼊点与通知的结合,决定了切⾯的定义,切⼊点定义了要拦截哪些类的哪些⽅法,通知则定义了拦 截过⽅法后要做什么,切⾯则是横切关注点的抽象,与类相似,类是对物体特征的抽象,切⾯则是横切 关注点抽象。
5.5.5. Target(⽬标对象) 被代理的⽬标对象
5.5.6. Weave(织⼊) 将切⾯应⽤到⽬标对象并⽣成代理对象的这个过程即为织⼊
5.5.7. Introduction(引⼊) 在不修改原有应⽤程序代码的情况下,在程序运⾏期为类动态添加⽅法或者字段的过程称为引⼊
6. Spring AOP的实现
6.1. Spring AOP环境搭建
6.1.1. 坐标依赖引⼊
6.1.2. 添加spring.xml的配置 添加命名空间 org.aspectj aspectjweaver 1.8.9 xmlns:aop="http://www.springframework.org/schema/aop" http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
6.2. 注解实现
6.2.1. 定义切⾯ /** * 切⾯ * 切⼊点和通知的抽象 (与⾯向对象中的 类 相似) * 定义 切⼊点和通知 (切⼊点定义了要拦截哪些类的哪些⽅法,通知则定义了拦截过⽅法后要做什 么) */ @Component // 将对象交给IOC容器去实例化 @Aspect // 声明当前类是⼀个切⾯ public class LogCut { /** * 切⼊点: * 匹配规则。规定什么⽅法被拦截、需要处理什么⽅法 * 定义切⼊点 * @Pointcut("匹配规则") * * Aop 切⼊点表达式简介 * 1. 执⾏任意公共⽅法: * execution(public *(..)) *
2. 执⾏任意的set⽅法 * execution(* set*(..)) *
3. 执⾏com.xxxx.service包下任意类的任意⽅法 * execution(* com.xxxx.service.*.*(..)) *
4. 执⾏com.xxxx.service 包 以及⼦包下任意类的任意⽅法 * execution(* com.xxxx.service..*.*(..)) * * 注:表达式中的第⼀个* 代表的是⽅法的修饰范围 * 可选值:private、protected、public (* 表示所有范围) */ @Pointcut("execution (* com.xxxx.service..*.*(..) )") public void cut(){} /** * 声明前置通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法执⾏前 执⾏该通知 * */ @Before(value = "cut()") public void before() { System.out.println("前置通知....."); } /** * 声明返回通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法(⽆异常)执⾏后 执⾏该通知 * */ @AfterReturning(value = "cut()") public void afterReturn() { System.out.println("返回通知....."); } /** * 声明最终通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法(⽆异常或有异常)执⾏后 执⾏该通知 * */ @After(value = "cut()") public void after() { System.out.println("最终通知....."); } /** * 声明异常通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法出现异常时 执⾏该通知 */ @AfterThrowing(value="cut()",throwing = "e") public void afterThrow(Exception e) { System.out.println("异常通知....." + " 异常原因:" + e.getCause()); } /** * 声明环绕通知 并将通知应⽤到切⼊点上 * ⽅法执⾏前后 通过环绕通知定义相应处理 * 需要通过显式调⽤对应的⽅法,否则⽆法访问指定⽅法 (pjp.proceed();) * @param pjp * @return */ @Around(value = "cut()") public Object around(ProceedingJoinPoint pjp) { System.out.println("前置通知..."); Object object = null; try { object = pjp.proceed(); System.out.println(pjp.getTarget() + "======" + pjp.getSignature()); // System.out.println("返回通知..."); } catch (Throwable throwable) { throwable.printStackTrace(); System.out.println("异常通知..."); }
6.2.2. 配置⽂件(spring.xml)
6.3. XML实现
6.3.1. 定义切⾯ System.out.println("最终通知..."); return object; } } ** * 切⾯ * 切⼊点和通知的抽象 (与⾯向对象中的 类 相似) * 定义 切⼊点和通知 (切⼊点定义了要拦截哪些类的哪些⽅法,通知则定义了拦截过⽅法后要做什 么) */ @Component // 将对象交给IOC容器去实例化 public class LogCut02 { public void cut(){} /** * 声明前置通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法执⾏前 执⾏该通知 * */ public void before() { System.out.println("前置通知....."); } /** * 声明返回通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法(⽆异常)执⾏后 执⾏该通知 * */ public void afterReturn() { System.out.println("返回通知....."); } /** * 声明最终通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法(⽆异常或有异常)执⾏后 执⾏该通知 * */ public void after() { System.out.println("最终通知....."); } /** * 声明异常通知 并将通知应⽤到定义的切⼊点上 * ⽬标类⽅法出现异常时 执⾏该通知 */ public void afterThrow(Exception e) { System.out.println("异常通知....." + " 异常原因:" + e.getCause()); } /** * 声明环绕通知 并将通知应⽤到切⼊点上 * ⽅法执⾏前后 通过环绕通知定义相应处理 * 需要通过显式调⽤对应的⽅法,否则⽆法访问指定⽅法 (pjp.proceed();) * @param pjp * @return */ public Object around(ProceedingJoinPoint pjp) { System.out.println("前置通知..."); Object object = null; try { object = pjp.proceed(); System.out.println(pjp.getTarget() + "======" + pjp.getSignature()); // System.out.println("返回通知..."); } catch (Throwable throwable) { throwable.printStackTrace(); System.out.println("异常通知..."); } System.out.println("最终通知..."); return object; }
6.3.2. 配置⽂件(spring.xml)
7. Spring AOP
总结
7.1. 代理模式实现三要素 1. 接⼝定义 2. ⽬标对象与代理对象必须实现统⼀接⼝ 3. 代理对象持有⽬标对象的引⽤ 增强⽬标对象⾏为
7.2. 代理模式实现分类以及对应区别 1. 静态代理:⼿动为⽬标对象制作代理对象,即在程序编译阶段完成代理对象的创建 2. 动态代理:在程序运⾏期动态创建⽬标对象对应代理对象。 3. jdk动态代理:被代理⽬标对象必须实现某⼀或某⼀组接⼝ 实现⽅式 通过回调创建代理对象。 4. cglib 动态代理:被代理⽬标对象可以不必实现接⼝,继承的⽅式实现。 动态代理相⽐较静态代理,提⾼开发效率,可以批量化创建代理,提⾼代码复⽤率。
7.3. Aop 理解 1. ⾯向切⾯,相⽐oop 关注的是代码中的层 或⾯ }