本文详细介绍了代理模式的概念，包括静态代理和动态代理。在静态代理中，通过创建代理类来扩展目标类的功能，但会导致类文件数量过多，维护困难。动态代理则通过反射在运行时生成代理对象，解决了静态代理的问题。在Java中，JDK提供了Proxy类来实现动态代理，而在Spring框架中，利用AOP实现动态代理，能够方便地为服务类添加如日志、事务等额外功能，提高了代码的可维护性和灵活性。文章还深入探讨了Spring的切入点表达式和切入点函数，以及如何使用MethodInterceptor进行更复杂的操作。
1. 代理设计模式概述
1.1 概念
为什么要有“代理”？生活中就有很多代理的例子，例如，我现在需要出国，但是我不愿意自己去办签证、预定机票和酒店（觉得麻烦 ，那么就可以找旅行社去帮我办，这时候旅行社就是代理，而我自己就是被代理了。
代理模式的定义：被代理者没有能力或者不愿意去完成某件事情，那么就需要找个人代替自己去完成这件事,这个人就是代理者,比如房东要出租房子，又不愿意自己去打广告找房客，于是找到了中介公司，于是中介公司就是代理者，房东就是被代理者。
1.2 为什么需要代理设计模式
简述：通过代理类为目标类增加额外的功能
好处：利于目标类维护
DAO —> Service --> Controller
JavaEE分层开发中，最为重要的是Service层，而Service层中 = 核心功能(几十行 上百代码) + 额外功能(附加功能)
1. 核心功能
业务运算
DAO调用
2. 额外功能
1. 不属于业务
2. 可有可无
3. 代码量很小
比如： 事务、日志、性能...
Service层的调用者的角度（Controller):需要在Service层书写额外功能，比如事务。
而从软件设计者的角度来看：Service层不需要额外功能，因为额外功能是可有可无的，需要的话可以有，但是如果不需要就需要删除功能，这就涉及改代码，影响系统维护性
现实生活中的解决方式–》中介，如果对原来中介提供的额外功能不满意，可以换一个中介（换一个新的代理 不需要修改代码 直接换一个新的代理类）
1.3 名词解释
- 目标类 原始类 被代理角色
一般指的是 业务类 (核心功能 --> 业务运算 DAO调用) - 目标方法，原始方法
目标类(原始类)中的方法 就是目标方法(原始方法) - 额外功能 (附加功能)
日志，事务，性能 - 代理角色 即实现了目标类的目标方法，又增加了额外功能
- 抽象角色(协议接口)：协定被代理角色和代理角色都需要实现的方法功能
1.4 代理开发的核心要素
代理类 = 目标类(原始类) + 额外功能 + 原始类(目标类)实现相同的接口
1.5 代码理解代理设计模式
假设 现在金莲和阎婆惜要出租房子 现在找了王婆代理
定义一个出租房子的协议接口，里面有一个出租房子的方法， 让王婆、金莲和阎婆惜都实现
协议接口
public interface RentOut {
public void rent();
}
金莲：（被代理角色）
public class Jinlian implements RentOut{
@Override
public void rent() {
System.out.println("金莲在出租房子....签合同");
}
}
阎婆惜:（被代理角色）
public class Yanpoxi implements RentOut{
@Override
public void rent() {
System.out.println("阎婆惜在出租房子。。。。签合同");
}
}
王婆(代理)
public class Wangpo implements RentOut{
RentOut h;
public Wangpo (RentOut h){
this.h=h;
}
@Override
public void rent() {
System.out.println("王婆的粗房子方法");
System.out.println("王婆的额外功能 ：打广告");
//然后调用房东h的rent方法 让房东去签合同
h.rent();
}
}
测试代码：
金莲和阎婆惜出租房子都可以去找王婆代理，广告由王婆来打
//静态代理模式:代理类是实际存在的， 根据代理类生成一个代理对象
public static void jinTaiDaiLi() {
Jinlian jl=new Jinlian();
Yanpoxi ypx=new Yanpoxi();
Wangpo wp=new Wangpo(jl);
//看起来是王婆在租房， 但是实际出租房子的是金莲
wp.rent();
//如果王婆类里面放的是RentOut接口类 那么所有实现了RentOut接口的对象都可以通过王婆代理去RentOut出租
Wangpo wp2=new Wangpo(ypx);
wp2.rent();
}
2. 静态代理
2.1 静态代理特点
代理类是实际存在的（上面的王婆）， 需要为每一个原始类，手工编写一个代理类 (.java .class)
2.2 静态代理实现
假如现在有OrderService和UserService两个业务，核心业务，运算和DAO调用可以直接在ServiceImpl中实现，而日志是可以交给代理来实现的， 方便维护
OrderService接口：
public interface OrderService {
public void showOrder();
}
OrderService实现类
public class OrderServiceImpl implements OrderService{
@Override
public void showOrder() {
System.out.println("OrderServiceImpl.showOrder 订单查询业务和DAO调用");
}
}
OrderService代理
public class OrderServiceProxy implements OrderService{
private OrderServiceImpl orderService=new OrderServiceImpl();
@Override
public void showOrder() {
System.out.println("OrderServiceProxy.showOrder");
System.out.println("showOrder方法的额外功能， 日志");
orderService.showOrder();
}
}
UserService接口
public interface UserService {
public void register(User user);
public boolean login(String name,String password);
}
UserService实现类
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 注册业务和DAO调用");
return false;
}
}
UserService代理类
public class UserServiceProxy implements UserService{
private UserServiceImpl userService =new UserServiceImpl();
@Override
public void register(User user) {
System.out.println("UserServiceProxy.register");
System.out.println("registe方法的额外功能， 日志");
userService.register(user);
}
@Override
public boolean login(String name, String password) {
System.out.println("UserServiceProxy.login");
System.out.println("login方法的额外功能， 日志");
userService.login(name,password);
return false;
}
}
2.3 静态代理存在的问题
- 静态类文件数量过多，不利于项目管理
UserServiceImpl UserServiceProxy
OrderServiceImpl OrderServiceProxy - 额外功能维护性差
代理类中 额外功能修改复杂(麻烦)
比如上面的日志实现后面要改，需要把每个代理每个方法的日志实现都改了
3.动态代理
3.1 动态代理介绍
概述 : 动态代理就是直接通过反射生成一个代理对象,代理对象所属的类是不需要存在的
3.2 JDK动态代理的获取:
jdk提供一个Proxy类可以直接给实现接口类的对象直接生成代理对象
3.3 JDK动态代理相关api介绍
Java.lang.reflect.Proxy类可以直接生成一个代理对象
- Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象
- 参数1:ClassLoader loader 动态字节码技术：借用类加载器生成代理类的class对象（这个地方借用的类可以随便找个类）
- 参数2:Class<?>[] interfaces 被代理类所有实现的接口的Class对象（代理和原始对象共同实现的接口）
- 参数3:InvocationHandler h 执行处理类,用来监听代理对象调用的方法,帮助我们代理对象调用方法
（额外功能的接口，用于书写（原始方法运行前，后，前后，抛出++异常时等）额外功能，运行原始方法） - 返回值: 代理对象
- 前2个参数是为了帮助在jvm内部生成被代理对象的代理对象,第3个参数,用来监听代理对象调用方法,帮助我们调用方法
//动态代理模式：代理类是不存在的，直接动态生成一个代理对象
//动态代理模式代理对象获取： 使用jdk提供的Proxy类可以直接给实现接口类的对象生成代理对象
public static void dongTaiDaiLi(){
Jinlian jl=new Jinlian();
//获取金莲的代理对象，相当于上面的WangPo
/*
参数1loader: 动态字节码技术：借用类加载器生成代理类的class对象（这个地方借用的类可以随便找个类）
参数2interfaces: 被代理类所有实现的接口的Class对象（代理和原始对象共同实现的接口）
参数3InvocationHandler: 执行处理类,用来监听代理对象调用的方法,帮助我们代理对象调用方法
（额外功能的接口，用于书写（原始方法运行前，后，前后，抛出++异常时等）额外功能，运行原始方法）
*/
RentOut proxyInstance =(RentOut) Proxy.newProxyInstance(Student.class.getClassLoader(),
Jinlian.class.getInterfaces(), new InvocationHandler() {
//代理对象调用方法就会执行invoke方法
/*
invoke回调方法: 当代理对象调用了方法,就会来执行该invoke方法, 在该方法中就可以增强被代理类的方法
Object proxy: 生成的代理对象 这里就是proxyInstance这个代理对象 (可以忽略掉)
Method method: 当前代理对象执行的方法 这里method就是happy()方法对象 （额外功能所增加给的原始方法）
Object[] args: 当前代理对象执行的方法,传入的实际参数（原始方法的参数）
返回值: 当前代理对象执行的方法的返回值（原始方法的返回值）
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("=====代理额外功能log=====");
//让金莲去出租房子签合同
Object ret = method.invoke(jl);
//如果原始方法也就是jl.rent()里面有参数
//method.invoke(jl，args);
System.out.println("=====代理额外功能 打扫房间=====");
return ret;
}
});
proxyInstance.rent();
}
4.Spring的动态代理开发
4.1 Spring动态代理的概念
概念：通过代理类为原始类(目标类)增加额外功能
好处：利于原始类(目标类)的维护
4.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>
4.3 Spring动态代理的开发步骤
4.3.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 注册业务和DAO调用");
return false;
}
}
配置文件中创建对象
<bean id="userService" class="com.tcgroup.service.UserServiceImpl"></bean>
4.3.2额外功能
额外的功能书写在MethodBeforeAdvice接口的实现中，运行时会在原始方法执行之前运行额外功能。
public class Before implements MethodBeforeAdvice {
/*
before方法的作用：
需要把运行在原始方法执行之前运行的额外功能，书写在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.tcgroup.dynamic.Before"/>
4.3.3定义切入点
切入点：额外功能加入的位置
目的：由程序员根据自己的需要，决定额外功能加入给那个原始方法
比如UserService的register和login方法
简单的测试：所有方法都做为切入点，都加入额外的功能。
<aop:config>
<!-- expression:切入点表达式
execution(*空格*(..)) 所有类的所有方法都作为切入点-->
<aop:pointcut id="pc" expression="execution(* *(..))"/>
</aop:config>
4.3.4组装 (把第二步和第三步整合)
<aop:config>
<!-- expression:切入点表达式
execution(*空格*(..)) 所有类的所有方法都作为切入点-->
<aop:pointcut id="pc" expression="execution(* *(..))"/>
<!-- 组装：目的：把切入点与额外功能进行整合 -->
<aop:advisor advice-ref="before" pointcut-ref="pc"/>
</aop:config>
4.3.5调用 (使用)
目的：获得Spring工厂创建的动态代理对象，并进行调用
@Test
public void test2(){
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("/applicationContext.xml");
/*
1. Spring的工厂通过原始对象的id值获得的是代理对象
2. 获得代理对象后，可以通过声明接口类型（UserService接口），进行对象的存储
*/
UserService userService=(UserService) classPathXmlApplicationContext.getBean("userService");
userService.login("zhangsan","123456");
userService.register(new User("xiaowang ","789456"));
OrderService orderService=(OrderService) classPathXmlApplicationContext.getBean("orderService");
orderService.showOrder();
}
4.4 动态代理细节分析
4.4.1 Spring创建的动态代理类在哪里？
Spring框架在运行时，通过动态字节码技术，在JVM创建的，运行在JVM内部，等程序结束后，会和JVM一起消失
什么叫动态字节码技术:通过第三个动态字节码框架，在JVM中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失。
结论：动态代理不需要定义类文件，都是JVM运行过程中动态创建的，所以不会造成静态代理，类文件数量过多，影响项目管理的问题。
4.4.2 动态代理编程简化代理的开发
在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始(目标)对象即可。
4.4.3 动态代理额外功能的维护性大大增强
如果额外功能由System.out.println("-----method before advice log------");变成了新的，那么可以重新创建一个类实现MethodBeforeAdvice接口，书写额外功能业务，然后把配置文件里面的额外功能对象改为新的即可
<!-- 额外功能 -->
<bean id="before" class="com.tcgroup.dynamic.Before"/>
5. Spring动态代理详解
5.1 额外功能的详解
5.1.1 MethodBeforeAdvice接口分析
MethodBeforeAdvice接口作用：额外功能运行在原始方法执行之前，进行额外功能操作。
public class Before implements MethodBeforeAdvice {
/*
before方法的作用：
需要把运行在原始方法执行之前运行的额外功能，书写在before方法中，也就是代理实现的额外功能
参数分析：
Method: 额外功能所增加给的那个原始方法
login方法
register方法
showOrder方法
Object[]: 额外功能所增加给的那个原始方法的参数。String name,String password, User 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方法的参数，在实战中，会根据需要进行使用，不一定都会用到，也有可能都不用。
5.2 MethodInterceptor(方法拦截器)
MethodBeforeAdvice接口: 只能在原始方法执行前执行
methodinterceptor接口：额外功能可以根据需要运行在原始方法执行 前、后、前后。
5.2.1 methodinterceptor接口实现
public class Arround implements MethodInterceptor {
/*
invoke方法的作用:额外功能书写在invoke
额外功能 原始方法之前
原始方法之后
原始方法执行之前 之后
确定：原始方法怎么运行 ：通过methodInvocation.proceed()运行
参数：MethodInvocation （Method):额外功能所增加给的那个原始方法 比如login register
invocation.proceed() ---> login运行 register运行
返回值：Object: 原始方法的返回值
*/
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
//额外功能运行在原始方法执行之前
long startTime = System.currentTimeMillis();
Object ret = methodInvocation.proceed();
//额外功能运行在原始方法执行之后
long endTime = System.currentTimeMillis();
System.out.println("花费时间："+(endTime-startTime)+"ms");
return ret;
}
}
把额外功能设置为实现了methodinterceptor接口的arround类
<bean id="arrount" class="com.tcgroup.dynamic.Arround"/>
<aop:config>
<!-- expression:切入点表达式
execution(*空格*(..)) 所有类的所有方法都作为切入点-->
<aop:pointcut id="pc" expression="execution(* *(..))"/>
<!-- 组装：目的：把切入点与额外功能进行整合 -->
<aop:advisor advice-ref="arrount" pointcut-ref="pc"/>
</aop:config>
5.2.2 额外功能运行在原始方法抛出异常的时候
public class Arround implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object ret = null;
try {
//额外功能运行在原始方法执行之前
long startTime = System.currentTimeMillis();
ret = methodInvocation.proceed();
//额外功能运行在原始方法执行之后
long endTime = System.currentTimeMillis();
System.out.println("花费时间："+(endTime-startTime)+"ms");
} catch (Throwable throwable) {
System.out.println("原始方法抛出异常的时候执行的额外功能逻辑代码");
throwable.printStackTrace();
}
return ret;
}
}
5.2.3 MethodInterceptor影响原始方法的返回值（正常开发很少进行干预）
原始方法的返回值，直接作为invoke方法的返回值返回，MethodInterceptor不会影响原始方法的返回值
Invoke方法的返回值，不要直接返回原始方法的运行结果即可影响原始方法的返回值，调用的返回值是return的值。
UserServiceImpl的login方法 原本是应该返回true的，通过Object ret = invocation.proceed()拿到的执行结果ret也是true，但是我们没有返回 ret ，而是直接返回了false，调用login方法的代码拿到的结果就是false
原始类:
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 注册业务和DAO调用");
return true;
}
}
MethodInterceptor(方法拦截器)
public class Arround implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
//额外功能运行在原始方法执行之前
long startTime = System.currentTimeMillis();
Object ret = methodInvocation.proceed();
//额外功能运行在原始方法执行之后
long endTime = System.currentTimeMillis();
System.out.println("花费时间："+(endTime-startTime)+"ms");
return false;
}
}
测试代码调用login原始方法
@Test
public void test2(){
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("/applicationContext.xml");
/*
1. Spring的工厂通过原始对象的id值获得的是代理对象
2. 获得代理对象后，可以通过声明接口类型（UserService接口），进行对象的存储
*/
UserService userService=(UserService) classPathXmlApplicationContext.getBean("userService");
boolean result = userService.login("zhangsan","123456");
System.out.println("result = " + result);
}
5.3 切入点表达式
5.3.1 方法切入点表达式
* *(..) --> 所有方法
* ---> 修饰符 返回值
* ---> 方法名
() ---> 参数表
.. ---> 对于参数没有要求 (参数有没有都行，参数有几个都行，参数是什么类型的都行)
定义login方法作为切入点
* login(..)
定义register作为切入点
* register(..)
定义必须有两个字符串类型参数的login方法 作为切入点
* login(String,String)
#注意：非java.lang包中的类型，必须要写全限定名
* register(com.tcgroup.entity.User)
…可以和具体的参数类型连用
* login(String,..)表示第一个参数是String类型的login方法即可，后面的参数不做要求
--> login(String),login(String,String),login(String,com.tcgroup.proxy.User)
精准方法切入点限定
修饰符 返回值 包.类.方法(参数)
* com.tcgroup.service.UserServiceImpl.login(..)
* com.tcgroup.service.UserServiceImpl.login(String,String)
5.3.2 类切入点表达式
指定特定类作为切入点(额外功能加入的位置)，自然这个类中的所有方法，都会加上对应的额外功能
- 语法1 指定包
#类中的所有方法加入了额外功能
* com.tcgroup.service.UserServiceImpl.*(..)
- 语法2 忽略包
1. 类只存在一级包 com.UserServiceImpl
* *.UserServiceImpl.*(..)
2. 类存在多级包 com.tcgroup.service.UserServiceImpl
* *..UserServiceImpl.*(..)
5.3.2 包切入点表达式
指定包作为额外功能加入的位置，自然包中的所有类及其方法都会加入额外的功能
- 语法1
#切入点包中的所有类，必须在service中，不能在service包的子包中
* com.tcgroup.service.*.*(..)
- 语法2
#切入点当前包及其子包都生效
* com.tcgroup.proxy..*.*(..)
5.4 切入点函数
切入点函数：用于执行切入点表达式
5.4.1.execution
最为重要的切入点函数，功能最全。
用于执行 方法切入点表达式 类切入点表达式 包切入点表达式
弊端：execution执行切入点表达式 ，书写麻烦
execution(* com.tcgroup.service..*.*(..))
注意：其他的切入点函数(后面的几个函数args，within。。。) 都是简化execution书写复杂度，功能上完全一致
5.4.2 args
作用：主要用于函数(方法) 参数的匹配
案例：
切入点要求是参数必须得是2个字符串类型的方法
execution函数: execution(* *(String,String))
args函数: args(String,String)
5.4.3 within
作用：主要用于进行类、包切入点表达式的匹配，忽略了修饰符 返回值及参数
切入点：UserServiceImpl这个类
execution函数: execution(* *..UserServiceImpl.*(..))
within函数: within(*..UserServiceImpl)
切入点：com.tcgroup.service下面的所有类和子包里面的类
execution函数: execution(* com.tcgroup.service..*.*(..))
within函数: within(com.tcgroup.service..*)
5.4.4 @annotation
作用：为具有特殊注解的方法加入额外功能
案例：
把具有Log注解的方法作为切入点加入额外功能
<aop:pointcut id="" expression="@annotation(com.tcgroup.anno.Log)"/>
5.5 切入点函数的逻辑运算
指的是 整合多个切入点函数一起配合工作，进而完成更为复杂的需求
5.5.1 and 与操作
案例：必须有两个字符串类型参数的login方法
1. execution(* login(String,String))
2. execution(* login(..)) and args(String,String)
注意：**与(and)操作不同用于同种类型的切入点函数 **
案例：假设UserServiceImpl类中除了有register方法 和 login方法，还有A,B,C三个方法 一共五个方法 我们需要把serServiceImpl类中的register方法 和 login方法作为切入点
错误操作：
execution(* login(..)) and execution(* register(..))
结果是register方法 和 login方法都没有切到，都没有实现额外功能
正确操作需要用下面的or运算
5.5.2 or 或操作
案例：register方法 和 login方法作为切入点
execution(* login(..)) or execution(* register(..))
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
