网站镜像 cdn,男和女做暖暖网站,微信上wordpress,wordpress chianz✅作者简介#xff1a;大家好#xff0c;我是Leo#xff0c;热爱Java后端开发者#xff0c;一个想要与大家共同进步的男人#x1f609;#x1f609; #x1f34e;个人主页#xff1a;Leo的博客 #x1f49e;当前专栏#xff1a; Spring专栏 ✨特色专栏#xff1a; M…
✅作者简介大家好我是Leo热爱Java后端开发者一个想要与大家共同进步的男人 个人主页Leo的博客 当前专栏 Spring专栏 ✨特色专栏 MySQL学习 本文内容Spring5学习笔记—AOP编程 ️个人小站 个人博客欢迎大家访问 个人知识库 知识库欢迎大家访问
1. 静态代理设计模式
1.1 为什么需要代理设计模式 在JavaEE分层开发开发中那个层次对于我们来讲最重要 DAO --- Service -- Controller JavaEE分层开发中最为重要的是Service层Service层中包含了哪些代码 Service层中 核心功能(几十行 上百代码) 额外功能(附加功能)
1. 核心功能业务运算DAO调用
2. 额外功能(事务、日志、性能...)1. 不属于业务2. 可有可无3. 代码量很小 额外功能书写在Service层中好不好 Controller层Service层的调用者除了需要核心功能还需要这些额外功能。 但是从软件设计者角度看Service层最好不要写额外功能。 现实生活中的解决方式
代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问这样就可以在不修改原目标对象的前提下提供额外的功能操作扩展目标对象的功能。
代理模式的主要作用是扩展目标对象的功能比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。 代理模式: 为一个对象提供一个替身以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象 举个例子当我们工作之后需要出去租房子房东张贴广告带我看房子最后签合同但是房东只想坐着签合同并不想到处跑着看房子于是就找了一个中介专门来宣传广告并且带租户看房子而房东只负责签合同收钱中介在这里就可以看作是代理你的代理对象代理的行为方法是带租户看房子。 1.2 代理设计模式分析
2.1 概念
通过代理类为原始类目标增加额外的功能 好处利于原始类(目标)的维护
2.2 名词解释
1. 目标类 原始类 指的是 业务类 (核心功能 -- 业务运算 DAO调用)
2. 目标方法原始方法目标类(原始类)中的方法 就是目标方法(原始方法)
3. 额外功能 (附加功能)日志事务性能2.3 代理开发的核心要素
代理类 实现和目标类相同的接口 在同名方法中添加额外功能 调用原始类同名方法房东 --- public interface UserService{m1m2}UserServiceImpl implements UserService{m1 --- 业务运算 DAO调用m2 }UserServiceProxy implements UserServicem1m22.4 编码
静态代理为每一个原始类手动编写一个代理类 (.java .class) 2.5 静态代理存在的问题
1. 静态类文件数量过多不利于项目管理UserServiceImpl UserServiceProxyOrderServiceImpl OrderServiceProxy
2. 额外功能维护性差代理类中 额外功能修改复杂(麻烦)2. Spring的动态代理开发
2.1 Spring动态代理的概念 概念通过代理类为原始类(目标类)增加额外功能,代理类由Spring动态生成。 好处利于原始类(目标类)的维护 2.2 搭建开发环境
dependencygroupIdorg.springframework/groupIdartifactIdspring-aop/artifactIdversion5.1.14.RELEASE/version
/dependencydependencygroupIdorg.aspectj/groupIdartifactIdaspectjrt/artifactIdversion1.8.8/version
/dependencydependencygroupIdorg.aspectj/groupIdartifactIdaspectjweaver/artifactIdversion1.8.3/version
/dependency2.3 Spring动态代理的开发步骤
1. 创建原始对象(目标对象)
public class UserServiceImpl implements UserService{Overridepublic void register(User user) {System.out.println(UserServiceImpl.register);}Overridepublic boolean login(String name, String password) {System.out.println(UserServiceImpl.login);return true;}
}
bean iduserServiceImpl classcom.Leo.dynamic.service.impl.UserServiceImpl/2. 定义额外功能
实现MethodBeforeAdvice接口
public class Before implements MethodBeforeAdvice {//作用给原始方法添加额外功能//注意会在原始方法运行之前运行此方法Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println(-----method before advice log------);}
}
bean idbefore classcom.Leo.dynamic.service.Before/3. 定义切入点
1. 切入点额外功能加入的位置2. 目的由程序员根据自己的需要决定额外功能加入给那个原始方法
register()
login()简单的测试所有方法都做为切入点都加入额外的功能。
aop:configaop:pointcut idpc expressionexecution(* *(..))/
/aop:config4. 组装
!-- 组装切入点与额外功能 --
aop:advisor advice-refbefore pointcut-refpc/5. 测试调用
目的获得Spring工厂创建的动态代理对象并进行调用
ApplicationContext ctx new ClassPathXmlApplicationContext(/applicationContext.xml);
注意1. Spring的工厂通过 原始对象的id值获得的是代理对象2. 获得代理对象后可以通过声明接口类型进行对象的存储UserService userService(UserService)ctx.getBean(userServiceImpl);userService.login(,);
userService.register(new User());控制台打印 可以发现在日志之前输入了 2.4 动态代理细节分析
4.1 Spring创建的动态代理类在哪里 Spring框架在运行时通过动态字节码技术在JVM创建的运行在JVM内部等程序结束后就消失了。 什么叫动态字节码技术:通过第三方动态字节码框架在JVM中创建对应类的字节码进而创建对象当虚拟机结束动态字节码跟着消失。 结论动态代理不需要定义类文件都是JVM运行过程中动态创建的所以不会造成静态代理类文件数量过多影响项目管理的问题。 4.2 动态代理编程简化代理的开发 在额外功能不改变的前提下创建其他目标类原始类的代理对象时只需要指定原始(目标)对象即可。 3. Spring动态代理详解
3.1 额外功能的详解 MethodBeforeAdvice分析 作用原始方法执行之前运行额外功能。 public class Before implements MethodBeforeAdvice {/*** 作用给原始方法添加额外功能* 注意会在原始方法运行之前运行此方法* param method 原始方法 login() register() ...* param objects 原始方法的参数列表 name password ...* param o 原始对象 UserServiceImpl OrderServiceImpl* throws Throwable 抛出的异常*/Overridepublic void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println(---- MethodBeforeAdvice log... ----);}
}实战需要时才用可能都会用到也有可能都不用。 MethodInterceptor(方法拦截器) MethodInterceptor接口额外功能可定义在原始方法执行 前、后、前和后。 public class Around implements MethodInterceptor {/*** param invocation 封装了原始方法 invocation.proceed()表示原始方法的运行* return 原始方法的返回值* throws Throwable 可能抛出的异常*/Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println(------ 额外功能 log -----);//原始方法的执行Object ret invocation.proceed();//返回原始方法的返回值return ret;}
}额外功能运行在原始方法执行之后 public Object invoke(MethodInvocation invocation) throws Throwable {Object ret invocation.proceed();System.out.println(-----额外功能运行在原始方法执行之后----);return ret;}额外功能运行在原始方法执行之前和之后实战事务需要在之前和之后都运行
Override
public Object invoke(MethodInvocation invocation) throws Throwable {System.out.println(-----额外功能运行在原始方法执行之前----);Object ret invocation.proceed();System.out.println(-----额外功能运行在原始方法执行之后----);return ret;
}额外功能运行在原始方法抛出异常时 Override
public Object invoke(MethodInvocation invocation) throws Throwable {Object ret null;try {ret invocation.proceed();} catch (Throwable throwable) {System.out.println(-----原始方法抛出异常 执行的额外功能 ---- );throwable.printStackTrace();}return ret;}MethodInterceptor可以影响原始方法的返回值
Override
public Object invoke(MethodInvocation invocation) throws Throwable {System.out.println(------log-----);Object ret invocation.proceed();//拿到原始方法的返回值后进行一些操作就会影响直接返回就不影响return false;
}3.2 切入点详解
切入点决定了额外功能加入的位置。
aop:pointcut idpc expressionexecution(* *(..))/
exection(* *(..)) --- 匹配了所有方法 a b c 1. execution() 切入点函数
2. * *(..) 切入点表达式 1. 切入点表达式 方法切入点表达式 * *(..) -- 所有方法* --- 修饰符 返回值
* --- 方法名
()--- 参数表
..--- 对于参数没有要求 (0个或多个)举例 # 定义login方法作为切入点* login(..)# 定义register作为切入点* register(..)# 定义名字为login且有两个字符串类型参数的方法 作为切入点* login(String,String)# 注意非java.lang包中的类型必须要写全限定名* register(com.Leo.proxy.User)# ..可以和具体的参数类型连用(至少有一个参数是String类型)* login(String,..)# 精准方法切入点限定# 修饰符 返回值 包.类.方法(参数)* com.yuziayn.proxy.UserServiceImpl.login(..)* com.Leo.proxy.UserServiceImpl.login(String,String)类切入点表达式 指定特定的类作为切入点即这个类中所有的方法都会加上额外功能。 举例 # 类中的所有方法都加入额外功能
* com.Leo.proxy.UserServiceImpl.*(..)# 忽略包
# 1. 类只在一级包下 com.UserServiceImpl
* *.UserServiceImpl.*(..)# 2. 类可在多级包下 com.Leo.proxy.UserServiceImpl
* *..UserServiceImpl.*(..)包切入点表达式 指定包作为切入点即这个包中的所有类及其方法都会加入额外的功能。 举例 # proxy包作为切入点即proxy包下所有类中的所有方法都会加入额外功能但是不包括其子包中的类
* com.Leo.proxy.*.*(..)# 当前包及其子包都生效
* com.Leo.proxy..*.*(..) 2 切入点函数
作用用于执行切入点表达式。 execution() 最为重要的切入点函数功能最全
用于执行方法切入点表达式、类切入点表达式、包切入点表达式 弊端execution执行切入点表达式 书写麻烦execution(* com.Leo.proxy..*.*(..))注意其他的切入点函数 只是简化execution书写复杂度功能上完全一致args() # 作用用于函数(方法)参数的匹配# 举例方法参数必须得是2个字符串类型的参数execution(* *(String,String))等价于args(String,String)within() # 作用用于进行类、包切入点表达式的匹配
# 举例
# UserServiceImpl类作为切入点execution(* *..UserServiceImpl.*(..))within(*..UserServiceImpl)
# proxy包作为切入点execution(* com.Leo.proxy..*.*(..))within(com.yuziayan.proxy..*)annotation() !-- 作用为具有特殊注解的方法加入额外功能 --aop:pointcut id expressionannotation(com.baizhiedu.Log)/切入点函数间的逻辑运算 目的整合多个切入点函数一起配合工作进而完成更为复杂的需求。 and 与操作同时满足 # 案例方法名为login同时有2个字符串类型的参数execution(* login(String,String))execution(* login(..)) and args(String,String)# 注意与操作不能用于同种类型的切入点函数
# 错误案例register方法 和 login方法作为切入点不能用and而用orexecution(* login(..)) and execution(* register(..))
# 上面的语句会发生错误因为其实际表达的含义是方法名为login同时方法名为register显然有悖逻辑此时应该用到的是 oror 或操作满足一种即可 # 案例register方法 和 login方法作为切入点 execution(* login(..)) or execution(* register(..))4. AOP编程
4.1 AOP概念
# AOP (Aspect Oriented Programing) 面向切面编程 Spring动态代理开发
# 以切面为基本单位的程序开发通过切面间的彼此协同相互调用完成程序的构建
# 切面 切入点 额外功能# OOP (Object Oriented Programing) 面向对象编程 Java
# 以对象为基本单位的程序开发通过对象间的彼此协同相互调用完成程序的构建# POP (Procedure Oriented Programing) 面向过程(方法、函数)编程 C
# 以过程为基本单位的程序开发通过过程间的彼此协同相互调用完成程序的构建# AOP的概念本质就是Spring的动态代理开发通过代理类为原始类增加额外功能。好处利于原始类的维护
# 注意AOP编程不可能取代OOP而是OOP编程的补充。4.2 AOP编程的开发步骤
原始对象额外功能 (MethodInterceptor)切入点组装切面 (额外功能切入点)
4.3 切面的名词解释
切面 切入点 额外功能 几何学面 点 相同的性质5. AOP的底层实现原理
5.1 核心问题
AOP如何创建动态代理类(动态字节码技术)Spring工厂如何加工创建代理对象通过原始对象的id值获得的是代理对象。
5.2 动态代理类的创建
1. JDK的动态代理 Proxy.newProxyInstance()方法参数详解: 编码 public class TestJDKProxy {public static void main(String[] args) {//1.创建原始对象//注意由于后面匿名子类的方法中用到了userService所以应该用final修饰// 而JDK1.8以后默认加了final不需要手动加UserService userService new UserServiceImpl();//2.JDK创建代理对象InvocationHandler handler new InvocationHandler() {Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println(----------- JDKProxy log -----------);\//目标方法运行Object ret method.invoke(userService, args);return ret;}};UserService userServiceProxy (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(),handler);userServiceProxy.login(Leo, 123456);userServiceProxy.register(new User());}
}2. CGlib的动态代理
原理通过父子继承关系创建代理对象。原始类作为父类代理类作为子类这样既可以保证2者方法一致同时在代理类中提供新的实现(额外功能原始方法) CGlib编码 package com.Leo.cglib;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class TestCGlibProxy {public static void main(String[] args) {//1.创建原始对象UserServiceImpl userService new UserServiceImpl();//2.通过CGlib创建代理对象// 2.1 创建EnhancerEnhancer enhancer new Enhancer();// 2.2 设置借用类加载器enhancer.setClassLoader(TestCGlibProxy.class.getClassLoader());// 2.3 设置父类目标类enhancer.setSuperclass(userService.getClass());// 2.4 设置回调额外功能写在里面enhancer.setCallback(new MethodInterceptor() {//相当于 InvocationHandler -- invoke()Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {//额外功能System.out.println( CGlibProxy log );//目标方法执行Object ret method.invoke(userService, objects);return ret;}});// 2.5 通过Enhancer对象创建代理UserServiceImpl service (UserServiceImpl) enhancer.create();//测试service.register();service.login();}
}3. 总结
1. JDK动态代理 Proxy.newProxyInstance()
# 通过目标类实现的接口创建代理类
2. Cglib动态代理 Enhancer
# 通过继承目标类创建代理类 5.3 Spring工厂如何返回代理对象
思路分析 编码模拟 public class ProxyBeanPostProcessor implements BeanPostProcessor {Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {InvocationHandler invocation new InvocationHandler() {Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println(----------- 模拟Spring返回代理对象的方式 log -----------);Object ret method.invoke(bean, args);return ret;}};return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), invocation);}
}!-- 1.配置原始对象 --bean iduserService classcom.Leo.factory.UserServiceImpl/bean!-- 2.配置自己模拟的ProxyBeanPostProcessor --bean idproxyBeanPostProcessor classcom.Leo.factory.ProxyBeanPostProcessor/6. 基于注解的AOP编程
6.1 开发步骤 原始对象 额外功能 切入点 组装切面 /*** 声明切面类 Aspect* 定义额外功能 Around* 定义切入点 Around(execution(* login(..)))**/
Aspect
public class MyAspect {Around(execution(* login(..)))//组装了切入点和额外功能public Object around(ProceedingJoinPoint joinPoint) throws Throwable {//额外功能System.out.println(--------- 基于注解的AOP编程 log --------);//原始方法执行Object ret joinPoint.proceed();return ret;}
}!-- 原始对象 --bean iduserService classcom.Leo.aspect.UserServiceImpl/bean!-- 切面 --bean idmyAspect classcom.Leo.aspect.MyAspect/!-- 开启基于注解的AOP编程 --aop:aspectj-autoproxy/6.2 细节分析 切入点复用 Aspect
public class MyAspect {/*** 切入点复用定义一个函数加上Pointcut注解通过该注解的value定义切入点表达式以后可以复用。*/Pointcut(execution(* login(..)))public void myPointcut(){}Around(myPointcut())//组装了切入点和额外功能public Object around(ProceedingJoinPoint joinPoint) throws Throwable {//额外功能System.out.println(--------- 基于注解的AOP编程 log --------);//原始方法执行Object ret joinPoint.proceed();return ret;}Around(myPointcut())public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {//额外功能System.out.println(--------- 基于注解的AOP编程 tx --------);//原始方法执行Object ret joinPoint.proceed();return ret;}}动态代理的创建方式 AOP底层实现 2种代理创建方式1. JDK 通过实现接口创建代理对象2. Cglib 通过继承目标类创建代理对象默认情况 AOP编程 底层应用JDK动态代理创建方式 如果要切换Cglib1. 基于注解AOP开发aop:aspectj-autoproxy proxy-target-classtrue /2. 传统的AOP开发aop:config proxy-target-classtrue/aop7. AOP开发中的一个坑
坑在同一个业务类中业务方法间相互调用时只有最外层的方法,加入了额外功能(内部的方法通过普通的方式调用运行的都是原始方法)。如果想让内层的方法也调用代理对象的方法就要实现AppicationContextAware获得工厂进而获得代理对象。
public class UserServiceImpl implements UserService, ApplicationContextAware {private ApplicationContext ctx;Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.ctx applicationContext;}LogOverridepublic void register(User user) {System.out.println(UserServiceImpl.register 业务运算 DAO );//throw new RuntimeException(测试异常);//调用的是原始对象的login方法 --- 核心功能/*设计目的代理对象的login方法 --- 额外功能核心功能ApplicationContext ctx new ClassPathXmlApplicationContext(/applicationContext2.xml);UserService userService (UserService) ctx.getBean(userService);userService.login();Spring工厂重量级资源 一个应用中 应该只创建一个工厂*/UserService userService (UserService) ctx.getBean(userService);userService.login(Leo, 123456);}Overridepublic boolean login(String name, String password) {System.out.println(UserServiceImpl.login);return true;}
}8. AOP阶段知识总结
