spring_aop编程：代理设计模式
静态代理
1、为什么需要代理设计模式
1.1 问题
在JavaEE分层开发开发中，那个层次对于我们来讲最重要
DAO ---> Service --> Controller
JavaEE分层开发中， 最为重要的是Service层
Service层中包含了哪些代码?
Service层中 = 核心功能(几十行上百代码) +额外功能(附加功能)
1.核心功能
- 业务运算
- DAO调用
2.额外功能
- 不属于业务
- 可有可无
- 代码量很小
(如：事务、日志、性能…）
-
事务：如增删改时提交事务，查询时不用
-
日志：记录（谁 + 时间 + 什么事 + 结果）【记录用户重要操作的"流水账"】
-
性能：开发阶段可能监控性能，但是发布阶段可能性能优化得特别好了，就不用进行监控性能的操作了
额外功能书写在Service层中好不好?
Service层的调用者的角度 (Controller) :
- 需要在Service层书写额外功能。
- 软件设计者：Service层不需要额外功能
- 生活中的解决方式
2、代理设计模式
1.1 概念
通过代理类，为原始类(目标)增加额外的功能
好处：利于原始类(目标)的维护
1.2 名词解释
a. 目标类 原始类
- 指的是业务类(核心功能–>业务运算DAO调用 )
b. 目标方法，原始方法
- 目标类 (原始类)中的方法就是目标方法(原始方法)
c. 额外功能(附加功能)
- 日志，事务，性能
1.3 代理开发的核心要素
代理类=目标类(原始类) +额外功能+原始类(目标类)实现相同的接口
房东---> public interface UserService{
m1
m2
}
UserServiceImpl implements UserService{
m1 ---> 业务运算DAO调用
m2
}
UserServiceProxy implements UserService{
m1
m2
}
1.4 实现
静态代理：为每一个原始类，手工编写一 个代理类 (.java .class)
1.5 静态代理存在的问题
静态类文件数量过多，不利于项目管理
- UserServiceImpl UserServiceProxy
- OrderServiceImpl OrderServiceProxy
- …
额外功能维护性差
代理类中额外功能修改复杂(麻烦)
Spring的动态代理开发
Spring动态代理的概念
-
概念：通过代理类为原始类(目标类)增加额外功能
-
好处：利于原始类(目标类)的维护
搭建开发环境
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.5</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.5</version>
</dependency>
开发步骤
1、创建原始对象（目标对象）
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.company.proxy.UserServiceImpl"/>
2、额外功能（实现MethodBeforeAdvice）
额外的功能书写在接口的实现中，运行在原始方法执行之前运行额外功能。
public class Before implements MethodBeforeAdvice {
/*
作用:需要把运行在原始方法执行之前运行的额外功能，书写在before方法中
*/
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("-----method before advice log-----");
}
}
<bean id="before" class="com.company.dynamic.Before"/>
3、定义切入点
- 切入点：额外功能加入的位置
- 目的：由程序员根据自己的需要，决定额外功能加入给那个原始方法
简单的测试：所有方法都做为切入点，都加入额外的功能。
<aop:config>
<aop:pointcut id="pc" expression="execution(* *(..))"/>
</aop:config>
4、对额外功能 与 切入点 组装整合
<aop:config>
<!--所有的方法， 都作为切入点，加入额外功能login register-->
<aop:pointcut id="pc" expression="execution(* *(..))"/>
<!--组装:目的把切入点与额外功能进行整合-->
<aop:advisor advice-ref="before" pointcut-ref="pc"/>
</aop:config>
5、调用
目的:获得Spring工厂创建的动态代理对象，并进行调用
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
注意:
1.Spring的工厂通过原始对象的id值获得的是代理对象
2.获得代理对象后，可以通过声明接口类型，进行对象的存储
UserService userService=(UserService)ctx.getBean("userService");
userService.login(" ")
userService.register()
动态代理细节分析
1、Spring创建的动态代理类在哪里?
Spring框架在运行时，通过动态字节码技术，在JVM创建的，运行在JVM内部，等程序结束后，会和JVM一起消失
什么叫动态字节码技术？
通过第三个动态字节码框架，在JVM中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失。
结论：动态代理不需要定义类文件，都是JVM运行过程中动态创建的，所以不会造成静态代理，类文件数量过多，影响项目管理的问题。
2、动态代理 编程简化代理的开发
在额外功能不改变的前提下， 创建其他目标类(原始类)的代理对象时，只需要指定原始(目标)对象即可。
3、动态代理额外功能的维护性大大增强
关闭修改，增加扩展
<!--<bean id="before" class="com.company.dynamic.Before"/>-->
<bean id="before" class="com.company.dynamic.Before1"/>
Spring动态代理详解
1、额外功能的详解
a. MethodBeforeAdvice 分析
1. MethodBeforeAdvice接口作用:额外功能运行在原始方法执行之前，进行额外功能操作。
public class Before implements MethodBeforeAdvice {
/*
作用:需要把运行在原始方法执行之前运行的额外功能，书写在before方法中
Method:额外功能所增加给的那个原始方法
login方法
register方法
showOrder方法
Object[]:额外功能所增加给的那个原始方法的参数。
login方法 ---> String name, String password
register方法 ---> User
Object:额外功能所增加给的那个原始对象
UserServiceImpl
OrderServiceImpl
*/
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("-----method before advice log-----");
}
}
2.before方法的3个参数在实战中，该如何使用。
before方法的参数，在实战中，会根据需要进行使用，不一定都会用到，也有可能都不用。
b. MethodInterceptor (方法拦截器)
methodinterceptor接口：额外功能可以根据需要运行在原始方法执行前、后、前后。
public class Arround implements MethodInterceptor {
/*
invoke方法的作用:额外功能书写在invoke
额外功能 原始方法之前
原始方法之后
原始方法执行之前 之后
确定:原始方法怎么运行
参数: MethodInvocation (Method) :额外功能所增加给的那个原始方法
login
register
invocation. proceed() ---> login运行
register运行
返回值: Object: 原始方法的返回值
*/
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("--- 前 额外功能 log ---");
Object ret = methodInvocation.proceed();
System.out.println("--- 后 额外功能 log ---");
return ret;
}
}
有什么样的额外功能运行在原始方法执行之前，之后都要添加？事务
额外功能运行在原始方法抛出异常的时候
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object ret = null;
try {
ret = methodInvocation.proceed();
} catch (Throwable throwable) {
System.out.println("原始方法抛出异常 执行的额外功能");
throwable.printStackTrace();
}
return ret;
}
MethodInterceptor影响原始方法的返回值
原始方法的返回值，直接作为invoke方法的返回值返回， MethodInterceptor不会影响原始方法的返回值
MethodInterceptor影响原始方法的返回值
Invoke方法的返回值，不要直接返回原始方法的运行结果即可。
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object ret = null;
ret = methodInvocation.proceed();
// 此时返回为false
return false;
}
2、切入点详解
切入点决定额外功能加入位置(方法)
<aop :pointcut id="pc" expression="execution(* *(..))"/>
exection(* *(..)) ---> 匹配了所有方法 a b c
1.execution() 切入点函数
2.* *(..) 切入点表达式
方法切入点
* *(..) --> 所有方法
* --->修饰符返回值
* --->方法名
() ---> 参数表
.. ---> 对于参数没有要求(参数有没有，参数有几个都行，参数是什么类型的都行)
-
定义login方法作为切入点
* login(..) 定义register作为切入点 * register(..) -
定义login方法且login方法有两个字符串类型的参数作为切入点
* login(String,String) 注意:非java.lang包中的类型,必须写全类名 * register(com.company.proxy.User) ..可以与具体的参数类型连用 * login(String,..) --> login(String),login(String,String),login(String,com.company.proxy.User) -
精准方法切入点限定
修饰符 返回值 包.类.方法(参数) * com.company.proxy.UserServiceImpl.login(..) * com.company.proxy.UserServiceImpl.login(String, String)
类切入点
指定特定类作为切入点(额外功能加入的位置)，自然这个类中的所有方法，都会加上对应的额外功能。
-
类中的所有方法加入了额外功能
* com.company.proxy.UserSerivceImpl.*(..) -
忽略包
1. 类只存在一级包 com.UserServiceImpl * *.UserServiceImpl.*(..) 2. 类存在多级包 com.company.proxy.UserServiceImpl * *..UserServiceImpl.*(..)
包切入点（常用）
指定包作为额外功能加入的位置，自然包中的所有类及其方法都会加入额外的功能
运用时可以将需要额外功能的放一个包，不用额外功能的放另外一个包
-
切入点包中的所有类，必须在proxy中， 不能在proxy包的子包中
* com.company.proxy.*.*(..) -
切入点当前包及其子包都生效
* com.company.proxy..*.*(..)
3、切入点函数
切入点函数：用于执行切入点表达式
1. execution
最为重要的切入点函数，功能最全。
执行方法切入点表达式类切入点表达式包切入点表达式
弊端: execution执行切入点表达式，书写麻烦
execution(* com.company.proxy..*.*(..))
注意:其他的切入点函数简化是execution书写复杂度，功能上完全一致
2. args
作用:主要用于函数(方法)参数的匹配
切入点:方法参数必须得是2个字符串类型的参数
execution(* *(String, String))
args(String, String)
3. within
作用:主要用于进行类、包切入点表达式的匹配
切入点: UserServiceImpl这个类
execution(* *..UserServiceImpl.*(..))
within( *..UserServiceImpl)
execution(* com.company.proxy..*.*(..))
within( com.company.proxy..*)
4. @annotation
作用:为具有特殊注解的方法加入额外功能
// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}
@Log
public void register(User user) {}
// 添加额外功能
<aop:pointcut id="pc" expression="@annotation(com.company.Log)"/>
5. 切入点函数的逻辑运算
指的是整合多个切入点函数一起配合工作，进而完成更为复杂的需求
- and（与操作）
案例: login同时 参数 2个字符串
1. execution(* login(String, String))
2. execution(* login(..)) and args(String, String)
注意:与操作不能用于同种类型的切入点函数
案例: register方法和login方法作为切入点
// execution(* login(..)) and execution(* register(..)) ---> 此时代表的是方法名既是login又是register的方法
execution(* login(..)) or execution(* register(..))
- or（或操作）
案例: register方法和login方法作为切入点
execution(* login(..)) or execution(* register(..))
4、总结
6514
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
