文章目录
Spring AOP 代理模式
代理模式在 Java 开发中是⼀种⽐较常⻅的设计模式。设计⽬的旨在为服务类与客户类之间插⼊其他功能，插⼊的功能对于调⽤者是透明的，起到伪装控制的作⽤。如租房的例⼦：房客、中介、房东。对应于代理模式中即：客户类、代理类 、委托类（被代理类）。
为某⼀个对象（委托类）提供⼀个代理（代理类），⽤来控制对这个对象的访问。委托类和代理类有⼀个共同的⽗类或⽗接⼝。代理类会对请求做预处理、过滤，将请求分配给指定对象。
代理模式的两个设计原则：
- 代理类 与 委托类 具有相似的⾏为（共同）
- 代理类增强委托类的⾏为
静态代理
某个对象提供⼀个代理，代理角色固定，以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。
代理的三要素
a.有共同的行为（结婚）— 接口
b.目标角色（新人）— 实现行为
c.代理角色（婚庆公司）— 实现行为、增强目标对象行为
静态代理的特点
1.目标角色固定（只能做单一的代理）
2.在应用程序执行前就得到目标角色
3.代理对象会增强目标对象的行为
4.当有大量代理行为时，会产生大量代理类，可能会产生“类爆炸”
静态代理的实现
1.定义共同行为接口
package com.xxxx.staticProxy;
/**
* 共同的行为 --- 接口
*/
public interface RentHouse {
//租房
public void toRentHouse();
}
package com.xxxx.staticProxy;
/**
* 共同行为 --- 接口
*/
public interface Marry {
//结婚
public void toMarry();
}
2.目标对象（实现行为）
package com.xxxx.staticProxy;
/**
* 目标角色（真实角色）---租客
*/
public class User implements RentHouse,Marry{
@Override
public void toRentHouse() {
System.out.println("我要租房！！！");
}
@Override
public void toMarry() {
System.out.println("我要结婚了！！！");
}
}
3.代理对象（实现行为、增强行为）
package com.xxxx.staticProxy;
/**
* 代理角色 --- 中介
* 实现目标角色的行为，并增强用户行为
*/
public class Agency implements RentHouse{
//目标对象
private RentHouse target;
//带参构造
public Agency(RentHouse target) {
this.target = target;
}
//实现目标角色的方法
@Override
public void toRentHouse() {
//功能的扩展
System.out.println("发布租房信息...");
//实现目标角色的方法
target.toRentHouse();
//功能的扩展
System.out.println("准备合同...");
}
}
package com.xxxx.staticProxy;
public class MarryCompany implements Marry {
//目标角色
private Marry marry;
//带参构造
//通过带参构造将形参赋值给目标角色
public MarryCompany(Marry marry) {
this.marry = marry;
}
@Override
public void toMarry() {
//增强行为，功能扩展
System.out.println("场地正在布置中...");
// 执⾏⽬标对象中的⽅法
marry.toMarry();
//功能扩展
System.out.println("新婚快乐，百年好合！");
}
}
4.通过代理对象实现目标角色对象的功能
package com.xxxx.staticProxy;
/**
* 静态代理
* 1.目标角色固定（只能做单一的代理）
* 2.在程序执行前就得到目标对象
* 3.代理对象会增强目标对象的行为
* 4.当有大量代理行为时，会产生大量代理类，可能会产生“类爆炸”
*/
public class Starter {
public static void main(String[] args) {
//静态代理
//得到目标角色
RentHouse target = new User();
//得到代理角色
Agency agency = new Agency(target);
//代理角色实现目标角色的行为
agency.toRentHouse();
//分隔符
System.out.println("-----------------------");
//得到目标角色
Marry marry = new User();
//代理角色
MarryCompany marryCompany = new MarryCompany(marry);
marryCompany.toMarry();
}
}
5.实现结果
发布租房信息...
我要租房！！！
准备合同...
-----------------------
场地正在布置中...
我要结婚了！！！
新婚快乐，百年好合！
静态代理对于代理的角色是固定的，如dao层有20个dao类，如果要对方法的访问权限进行代理，此时需要创建20个静态代理角色，引起类爆炸，无法满足生产上的需要，于是就催生了动态代理的思想。
动态代理
相⽐于静态代理，动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运⾏时，由Java反射机制动态产⽣。它会根据需要，通过反射机制在程序运⾏期动态地为⽬标对象创建代理对象，⽆需程序员⼿动编写它的源代码。动态代理不仅简化了编程⼯作，⽽且提⾼了软件系统的可扩展性，因为反射机制可以⽣成任意类型的动态代理类。代理的⾏为可以代理多个⽅法，即满⾜⽣产需要的同时⼜达到代码通⽤的⽬的。
动态代理的两种实现方式：JDK动态代理 和 CGLIB动态代理
动态代理的特点
1.目标对象不固定
2.在应用程序执行时动态创建目标对象
3.代理对象会增强目标对象的行为
JDK 动态代理
注：JDK动态代理的目标对象必须有接口实现
newProxyInstance
Proxy类：
Proxy类是专⻔完成代理的操作类，可以通过此类为⼀个或多个接⼝动态地⽣成实现类，此类提供了如下操作⽅法：
* 得到代理对象
* newProxyInstance：返回⼀个指定接口的代理类的实例方法调用分配到指定的调用处理程序。 (返回代理对象)
* loader：⼀个ClassLoader对象，定义了由哪个ClassLoader对象来对⽣成的代理对象进⾏加载
* interfaces：⼀个Interface对象的数组，表示的是我将要给我需要代理的对象提供⼀组什么接⼝，
* 如果我提供了⼀组接⼝给它，那么这个代理对象就宣称实现了该接⼝(多态)，这样我就能调⽤这组接⼝中的⽅法了
* h：⼀个InvocationHandler接⼝，表示代理实例的调⽤处理程序实现的接⼝。
* 每个代理实例都具有⼀个关联的调⽤处理程序。
* 对代理实例调⽤⽅法时，将对⽅法调⽤进⾏编码并将其指派到它的调⽤处理程序的 invoke ⽅法
* （传⼊InvocationHandler接⼝的⼦类）
* public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
获取代理对象
package com.xxxx.jdkProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* JDK动态代理
* 通过Proxy类中的newProxyInstance，返回一个代理对象
*
* 注：使用jdk动态代理，必须要有接口实现
*/
public class JdkProxy{
//目标角色
private Object target;// ⽬标对象的类型不固定，创建时动态⽣成
//通过带参构造，传递目标对象
public JdkProxy(Object target) {
this.target = target;
}
//得到代理对象
public Object getProxy(){
//得到类加载器
ClassLoader classLoader = this.getClass().getClassLoader();
//得到目标对象实现的接口数组
Class[] interfaces = target.getClass().getInterfaces();
//⼀个InvocationHandler接口
InvocationHandler invocationHandler = new InvocationHandler() {
/**
* 当代理实例中对应的方法被调用时，invoke方法就会执行一次。
* 1.调用目标对象的方法
* 2.增强目标对象的行为
* @param proxy 调用该方法的代理对象
* @param method 目标对象的方法
* @param args 目标对象的方法形参
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("invoke...");
//目标增强
System.out.println("==============⽅法执⾏前");
//调用目标对象中的方法 invoke
method.invoke(target,args);//反射中的方法
//目标增强
System.out.println("==============⽅法执⾏后");
//方法的返回值
return null;
}
};
//得到代理对象实例
Object proxy = Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
//返回代理
return proxy;
}
}
通过代理对象实现目标对象的功能
package com.xxxx.jdkProxy;
import com.xxxx.staticProxy.RentHouse;
import com.xxxx.staticProxy.User;
public class JdkProxyTest {
public static void main(String[] args) {
//目标对象
RentHouse target = new User();
//获取代理类
JdkProxy jdkProxy = new JdkProxy(target);
//调用代理类中的方法，得到代理对象
RentHouse rentHouse= (RentHouse) jdkProxy.getProxy();
// 通过代理对象调⽤⽬标对象中的⽅法
rentHouse.toRentHouse();
}
}
运行结果
invoke...
==============⽅法执⾏前
我要租房！！！
==============⽅法执⾏后
Java动态代理类中的invoke是怎么调用的？
在生成的动态代理类$Proxy0.class中，构造方法调⽤了方类Proxy.class的构造⽅法，给成员变量invocationHandler赋值，
$Proxy0.class的static模块中创建了被代理类的⽅法，调⽤相应方法时方法体中调⽤了父类中的成员变量InvocationHandler的invoke()。
注：JDK的动态代理依靠接⼝实现，如果有些类并没有接⼝实现，则不能使⽤JDK代理。
CGLIB 动态代理
JDK 的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用 JDK 的动态代理，CGLIB 是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对 final 修饰的类进行代理。
添加依赖
在pom.xml文件中引入 CGLIB 的相关依赖。
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
定义类
实现 MethodInterceptor 接口
package com.xxxx.cglibProxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* CGLIB 动态代理
* 采用的是继承思想，生成一个子类继承目标对象（目标类不能用final修饰）
*
*/
public class CglibProxy {
//目标对象
private Object target;
//通过带参构造，传递目标对象
public CglibProxy(Object target) {
this.target = target;
}
/**
* 获取代理对象
* @return
*/
public Object getProxy(){
//得到Enhancer对象，通过调用Enhancer的create()方法，生成一个类（代理对象）
Enhancer enhancer = new Enhancer();
//设置父类（将目标对象设置成当前生成类的父类）
enhancer.setSuperclass(target.getClass());
//获取拦截器
MethodInterceptor methodInterceptor = new MethodInterceptor() {
/**
* 每当代理实例中的方法被调用时，intercept方法就会执行
* @param o 由CGLib动态⽣成的代理类实例
* @param method 实体类所调⽤的被代理的⽅法引⽤
* @param objects 参数值列表
* @param methodProxy ⽣成的代理类对⽅法的代理引⽤
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("intercept...");
//增强行为
System.out.println("目标对象方法执行前");
//调用目标对象的方法
Object object = methodProxy.invoke(target,objects);
//增强行为
System.out.println("目标对象方法执行后");
return object;
}
};
//设置拦截器
enhancer.setCallback(methodInterceptor);
//返回生成的代理类
return enhancer.create();
}
}
调用方法
package com.xxxx.cglibProxy;
import com.xxxx.staticProxy.RentHouse;
import com.xxxx.staticProxy.User;
public class CglibProxyTest {
public static void main(String[] args) {
//目标对象
RentHouse target = new User();
//得到代理类
CglibProxy cglibProxy =new CglibProxy(target);
//得到目标对象的代理对象
RentHouse proxy = (RentHouse) cglibProxy.getProxy();
//通过代理对象调用目标对象的方法
proxy.toRentHouse();
}
}
JDK 代理与 CGLIB 代理的区别
- JDK动态代理实现接⼝，Cglib动态代理继承思想
- JDK动态代理（⽬标对象存在接⼝时）执⾏效率⾼于Cglib
- 如果⽬标对象有接⼝实现，选择JDK代理，如果没有接⼝实现选择Cglib代理