Spring一套全通3—AOP编程
2021/11/8 17:13:59
本文主要是介绍Spring一套全通3—AOP编程,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
百知教育 — Spring系列课程 — AOP编程
第一章、静态代理设计模式
1. 为什么需要代理设计模式
1.1 问题
-
在JavaEE分层开发开发中,那个层次对于我们来讲最重要
DAO ---> Service --> Controller JavaEE分层开发中,最为重要的是Service层
-
Service层中包含了哪些代码?
Service层中 = 核心功能(几十行 上百代码) + 额外功能(附加功能) 1. 核心功能 业务运算 DAO调用 2. 额外功能 1. 不属于业务 2. 可有可无 3. 代码量很小 事务、日志、性能...
-
额外功能书写在Service层中好不好?
Service层的调用者的角度(Controller):需要在Service层书写额外功能。 软件设计者:Service层不需要额外功能
-
现实生活中的解决方式
2. 代理设计模式
1.1 概念
通过代理类,为原始类(目标)增加额外的功能 好处:利于原始类(目标)的维护
1.2名词解释
1. 目标类 原始类 指的是 业务类 (核心功能 --> 业务运算 DAO调用) 2. 目标方法,原始方法 目标类(原始类)中的方法 就是目标方法(原始方法) 3. 额外功能 (附加功能) 日志,事务,性能
1.3 代理开发的核心要素
代理类 = 目标类(原始类) + 额外功能 + 原始类(目标类)实现相同的接口 房东 ---> public interface UserService{ m1 m2 } UserServiceImpl implements UserService{ m1 ---> 业务运算 DAO调用 m2 } UserServiceProxy implements UserService m1 m2
1.4 编码
静态代理:为每一个原始类,手工编写一个代理类 (.java .class)
1.5 静态代理存在的问题
1. 静态类文件数量过多,不利于项目管理 UserServiceImpl UserServiceProxy OrderServiceImpl OrderServiceProxy 2. 额外功能维护性差 代理类中 额外功能修改复杂(麻烦)
第二章、Spring的动态代理开发
1. Spring动态代理的概念
概念:通过代理类为原始类(目标类)增加额外功能 好处:利于原始类(目标类)的维护
2. 搭建开发环境
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>5.1.14.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.8.8</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.3</version> </dependency>
3. Spring动态代理的开发步骤
-
创建原始对象(目标对象)
public class UserServiceImpl implements UserService { @Override public void register(User user) { System.out.println("UserServiceImpl.register 业务运算 + DAO "); } @Override public boolean login(String name, String password) { System.out.println("UserServiceImpl.login"); return true; } }
<bean id="userService" class="com.baizhiedu.proxy.UserServiceImpl"/>
-
额外功能
MethodBeforeAdvice接口额外的功能书写在接口的实现中,运行在原始方法执行之前运行额外功能。
public class Before implements MethodBeforeAdvice { /* 作用:需要把运行在原始方法执行之前运行的额外功能,书写在before方法中 */ @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println("-----method before advice log------"); } }
<bean id="before" class="com.baizhiedu.dynamic.Before"/>
-
定义切入点
切入点:额外功能加入的位置 目的:由程序员根据自己的需要,决定额外功能加入给那个原始方法 register login 简单的测试:所有方法都做为切入点,都加入额外的功能。
<aop:config> <aop:pointcut id="pc" expression="execution(* *(..))"/> </aop:config>
-
组装 (2 3整合)
表达的含义:所有的方法 都加入 before的额外功能 <aop:advisor advice-ref="before" pointcut-ref="pc"/>
-
调用
目的:获得Spring工厂创建的动态代理对象,并进行调用 ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml"); 注意: 1. Spring的工厂通过原始对象的id值获得的是代理对象 2. 获得代理对象后,可以通过声明接口类型,进行对象的存储 UserService userService=(UserService)ctx.getBean("userService"); userService.login("") userService.register()
4. 动态代理细节分析
-
Spring创建的动态代理类在哪里?
Spring框架在运行时,通过动态字节码技术,在JVM创建的,运行在JVM内部,等程序结束后,会和JVM一起消失 什么叫动态字节码技术:通过第三个动态字节码框架,在JVM中创建对应类的字节码,进而创建对象,当虚拟机结束,动态字节码跟着消失。 结论:动态代理不需要定义类文件,都是JVM运行过程中动态创建的,所以不会造成静态代理,类文件数量过多,影响项目管理的问题。
-
动态代理编程简化代理的开发
在额外功能不改变的前提下,创建其他目标类(原始类)的代理对象时,只需要指定原始(目标)对象即可。
-
动态代理额外功能的维护性大大增强
-
第三章、Spring动态代理详解
1. 额外功能的详解
-
MethodBeforeAdvice分析
1. MethodBeforeAdvice接口作用:额外功能运行在原始方法执行之前,进行额外功能操作。 public class Before1 implements MethodBeforeAdvice { /* 作用:需要把运行在原始方法执行之前运行的额外功能,书写在before方法中 Method: 额外功能所增加给的那个原始方法 login方法 register方法 showOrder方法 Object[]: 额外功能所增加给的那个原始方法的参数。String name,String password User Object: 额外功能所增加给的那个原始对象 UserServiceImpl OrderServiceImpl */ @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println("-----new method before advice log------"); } } 2. before方法的3个参数在实战中,该如何使用。 before方法的参数,在实战中,会根据需要进行使用,不一定都会用到,也有可能都不用。 Servlet{ service(HttpRequest request,HttpResponse response){ request.getParameter("name") --> response.getWriter() ---> } }
-
MethodInterceptor(方法拦截器)
methodinterceptor接口:额外功能可以根据需要运行在原始方法执行 前、后、前后。
public class Arround implements MethodInterceptor { /* invoke方法的作用:额外功能书写在invoke 额外功能 原始方法之前 原始方法之后 原始方法执行之前 之后 确定:原始方法怎么运行 参数:MethodInvocation (Method):额外功能所增加给的那个原始方法 login register invocation.proceed() ---> login运行 register运行 返回值:Object: 原始方法的返回值 Date convert(String name) */ @Override public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println("-----额外功能 log----"); Object ret = invocation.proceed(); return ret; } }
额外功能运行在原始方法执行之后
@Override 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影响原始方法的返回值
原始方法的返回值,直接作为invoke方法的返回值返回,MethodInterceptor不会影响原始方法的返回值 MethodInterceptor影响原始方法的返回值 Invoke方法的返回值,不要直接返回原始方法的运行结果即可。 @Override public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println("------log-----"); Object ret = invocation.proceed(); return false; }
2. 切入点详解
切入点决定额外功能加入位置(方法) <aop:pointcut id="pc" expression="execution(* *(..))"/> exection(* *(..)) ---> 匹配了所有方法 a b c 1. execution() 切入点函数 2. * *(..) 切入点表达式
2.1 切入点表达式
-
方法切入点表达式
![image-20200425105040237](./百知教育 — Spring系列课程 — AOP编程.assets/image-20200425105040237.png)* *(..) --> 所有方法 * ---> 修饰符 返回值 * ---> 方法名 ()---> 参数表 ..---> 对于参数没有要求 (参数有没有,参数有几个都行,参数是什么类型的都行)
-
定义login方法作为切入点
* login(..) # 定义register作为切入点 * register(..)
-
定义login方法且login方法有两个字符串类型的参数 作为切入点
* login(String,String) #注意:非java.lang包中的类型,必须要写全限定名 * register(com.baizhiedu.proxy.User) # ..可以和具体的参数类型连用 * login(String,..) --> login(String),login(String,String),login(String,com.baizhiedu.proxy.User)
-
精准方法切入点限定
修饰符 返回值 包.类.方法(参数) * com.baizhiedu.proxy.UserServiceImpl.login(..) * com.baizhiedu.proxy.UserServiceImpl.login(String,String)
-
-
类切入点
指定特定类作为切入点(额外功能加入的位置),自然这个类中的所有方法,都会加上对应的额外功能
-
语法1
#类中的所有方法加入了额外功能 * com.baizhiedu.proxy.UserServiceImpl.*(..)
-
语法2
#忽略包 1. 类只存在一级包 com.UserServiceImpl * *.UserServiceImpl.*(..) 2. 类存在多级包 com.baizhiedu.proxy.UserServiceImpl * *..UserServiceImpl.*(..)
-
-
包切入点表达式 实战
指定包作为额外功能加入的位置,自然包中的所有类及其方法都会加入额外的功能
-
语法1
#切入点包中的所有类,必须在proxy中,不能在proxy包的子包中 * com.baizhiedu.proxy.*.*(..)
-
语法2
#切入点当前包及其子包都生效 * com.baizhiedu.proxy..*.*(..)
-
2.2 切入点函数
切入点函数:用于执行切入点表达式
-
execution
最为重要的切入点函数,功能最全。 执行 方法切入点表达式 类切入点表达式 包切入点表达式 弊端:execution执行切入点表达式 ,书写麻烦 execution(* com.baizhiedu.proxy..*.*(..)) 注意:其他的切入点函数 简化是execution书写复杂度,功能上完全一致
-
args
作用:主要用于函数(方法) 参数的匹配 切入点:方法参数必须得是2个字符串类型的参数 execution(* *(String,String)) args(String,String)
-
within
作用:主要用于进行类、包切入点表达式的匹配 切入点:UserServiceImpl这个类 execution(* *..UserServiceImpl.*(..)) within(*..UserServiceImpl) execution(* com.baizhiedu.proxy..*.*(..)) within(com.baizhiedu.proxy..*)
4.@annotation
作用:为具有特殊注解的方法加入额外功能 <aop:pointcut id="" expression="@annotation(com.baizhiedu.Log)"/>
-
切入点函数的逻辑运算
指的是 整合多个切入点函数一起配合工作,进而完成更为复杂的需求
-
and与操作
案例:login 同时 参数 2个字符串 1. execution(* login(String,String)) 2. execution(* login(..)) and args(String,String) 注意:与操作不同用于同种类型的切入点函数 案例:register方法 和 login方法作为切入点 execution(* login(..)) or execution(* register(..))
-
or或操作
案例:register方法 和 login方法作为切入点 execution(* login(..)) or execution(* register(..))
-
第四章、AOP编程
1. AOP概念
AOP (Aspect Oriented Programing) 面向切面编程 = Spring动态代理开发 以切面为基本单位的程序开发,通过切面间的彼此协同,相互调用,完成程序的构建 切面 = 切入点 + 额外功能 OOP (Object Oritened Programing) 面向对象编程 Java 以对象为基本单位的程序开发,通过对象间的彼此协同,相互调用,完成程序的构建 POP (Producer Oriented Programing) 面向过程(方法、函数)编程 C 以过程为基本单位的程序开发,通过过程间的彼此协同,相互调用,完成程序的构建
AOP的概念: 本质就是Spring得动态代理开发,通过代理类为原始类增加额外功能。 好处:利于原始类的维护 注意:AOP编程不可能取代OOP,OOP编程有意补充。
2. AOP编程的开发步骤
1. 原始对象 2. 额外功能 (MethodInterceptor) 3. 切入点 4. 组装切面 (额外功能+切入点)
3. 切面的名词解释
切面 = 切入点 + 额外功能 几何学 面 = 点 + 相同的性质
第五章、AOP的底层实现原理
1. 核心问题
1. AOP如何创建动态代理类(动态字节码技术) 2. Spring工厂如何加工创建代理对象 通过原始对象的id值,获得的是代理对象
2. 动态代理类的创建
2.1 JDK的动态代理
- Proxy.newProxyInstance方法参数详解
-
编码
public class TestJDKProxy { /* 1. 借用类加载器 TestJDKProxy UserServiceImpl 2. JDK8.x前 final UserService userService = new UserServiceImpl(); */ public static void main(String[] args) { //1 创建原始对象 UserService userService = new UserServiceImpl(); //2 JDK创建动态代理 /* */ InvocationHandler handler = new InvocationHandler(){ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("------proxy log --------"); //原始方法运行 Object ret = method.invoke(userService, args); return ret; } }; UserService userServiceProxy = (UserService)Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(),userService.getClass().getInterfaces(),handler); userServiceProxy.login("suns", "123456"); userServiceProxy.register(new User()); } }
2.2 CGlib的动态代理
CGlib创建动态代理的原理:父子继承关系创建代理对象,原始类作为父类,代理类作为子类,这样既可以保证2者方法一致,同时在代理类中提供新的实现(额外功能+原始方法)
-
CGlib编码
package com.baizhiedu.cglib; import com.baizhiedu.proxy.User; 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 TestCglib { public static void main(String[] args) { //1 创建原始对象 UserService userService = new UserService(); /* 2 通过cglib方式创建动态代理对象 Proxy.newProxyInstance(classloader,interface,invocationhandler) Enhancer.setClassLoader() Enhancer.setSuperClass() Enhancer.setCallback(); ---> MethodInterceptor(cglib) Enhancer.create() ---> 代理 */ Enhancer enhancer = new Enhancer(); enhancer.setClassLoader(TestCglib.class.getClassLoader()); enhancer.setSuperclass(userService.getClass()); MethodInterceptor interceptor = new MethodInterceptor() { //等同于 InvocationHandler --- invoke @Override public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("---cglib log----"); Object ret = method.invoke(userService, args); return ret; } }; enhancer.setCallback(interceptor); UserService userServiceProxy = (UserService) enhancer.create(); userServiceProxy.login("suns", "123345"); userServiceProxy.register(new User()); } }
-
总结
1. JDK动态代理 Proxy.newProxyInstance() 通过接口创建代理的实现类 2. Cglib动态代理 Enhancer 通过继承父类创建的代理类
3. Spring工厂如何加工原始对象
-
思路分析
-
编码
public class ProxyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override /* Proxy.newProxyInstance(); */ public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { InvocationHandler handler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("----- new Log-----"); Object ret = method.invoke(bean, args); return ret; } }; return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(),bean.getClass().getInterfaces(),handler); } }
<bean id="userService" class="com.baizhiedu.factory.UserServiceImpl"/> <!--1. 实现BeanPostProcessor 进行加工 2. 配置文件中对BeanPostProcessor进行配置 --> <bean id="proxyBeanPostProcessor" class="com.baizhiedu.factory.ProxyBeanPostProcessor"/>
第六章、基于注解的AOP编程
1. 基于注解的AOP编程的开发步骤
-
原始对象
-
额外功能
-
切入点
-
组装切面
# 通过切面类 定义了 额外功能 @Around 定义了 切入点 @Around("execution(* login(..))") @Aspect 切面类 package com.baizhiedu.aspect; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; /* 1. 额外功能 public class MyArround implements MethodInterceptor{ public Object invoke(MethodInvocation invocation){ Object ret = invocation.proceed(); return ret; } } 2. 切入点 <aop:config <aop:pointcut id="" expression="execution(* login(..))"/> */ @Aspect public class MyAspect { @Around("execution(* login(..))") public Object arround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect log ------"); Object ret = joinPoint.proceed(); return ret; } }
<bean id="userService" class="com.baizhiedu.aspect.UserServiceImpl"/> <!-- 切面 1. 额外功能 2. 切入点 3. 组装切面 --> <bean id="arround" class="com.baizhiedu.aspect.MyAspect"/> <!--告知Spring基于注解进行AOP编程--> <aop:aspectj-autoproxy />
2. 细节
-
切入点复用
切入点复用:在切面类中定义一个函数 上面@Pointcut注解 通过这种方式,定义切入点表达式,后续更加有利于切入点复用。 @Aspect public class MyAspect { @Pointcut("execution(* login(..))") public void myPointcut(){} @Around(value="myPointcut()") public Object arround(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect log ------"); Object ret = joinPoint.proceed(); return ret; } @Around(value="myPointcut()") public Object arround1(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("----aspect tx ------"); Object ret = joinPoint.proceed(); return ret; } }
-
动态代理的创建方式
AOP底层实现 2种代理创建方式 1. JDK 通过实现接口 做新的实现类方式 创建代理对象 2. Cglib通过继承父类 做新的子类 创建代理对象 默认情况 AOP编程 底层应用JDK动态代理创建方式 如果切换Cglib 1. 基于注解AOP开发 <aop:aspectj-autoproxy proxy-target-class="true" /> 2. 传统的AOP开发 <aop:config proxy-target-class="true"> </aop>
第七章、AOP开发中的一个坑
坑:在同一个业务类中,进行业务方法间的相互调用,只有最外层的方法,才是加入了额外功能(内部的方法,通过普通的方式调用,都调用的是原始方法)。如果想让内层的方法也调用代理对象的方法,就要AppicationContextAware获得工厂,进而获得代理对象。 public class UserServiceImpl implements UserService, ApplicationContextAware { private ApplicationContext ctx; @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.ctx = applicationContext; } @Log @Override public 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("suns", "123456"); } @Override public boolean login(String name, String password) { System.out.println("UserServiceImpl.login"); return true; } }
第八章、AOP阶段知识总结
这篇关于Spring一套全通3—AOP编程的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-11-23Springboot应用的多环境打包入门
- 2024-11-23Springboot应用的生产发布入门教程
- 2024-11-23Python编程入门指南
- 2024-11-23Java创业入门:从零开始的编程之旅
- 2024-11-23Java创业入门:新手必读的Java编程与创业指南
- 2024-11-23Java对接阿里云智能语音服务入门详解
- 2024-11-23Java对接阿里云智能语音服务入门教程
- 2024-11-23JAVA对接阿里云智能语音服务入门教程
- 2024-11-23Java副业入门:初学者的简单教程
- 2024-11-23JAVA副业入门:初学者的实战指南