代理模式
一、概念
1、定义
代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。同时代理对象可以调用被代理对象的方法,并对其进行增强。可以总结为代理对象 = 增强代码 + 目标对象(原对象)
2、举例
疫情期间很多公司破产,导致很多劳动者都失业了,小文也是其中之一。公司拖欠小文的工资一直未能下发。小文希望通过劳动仲裁来要回属于自己的工资,所以和公司打官司。基本的仲裁步骤小文都懂,大概有:准备劳动仲裁申请书、收集证据、提交申请、开庭答辩等等,但是小文是第一次进行劳动仲裁,对这些具体的操作没什么经验,同时自己在这期间又有了新的工作,很难抽出时间去进行劳动仲裁。这时小文就掏钱找了一位律师,这位律师就相当于代理对象。律师替小文准备仲裁申请、提交申请、开庭后帮小文进行辩论阐述等等,律师不仅仅是按着仲裁需要的步骤做了,而且每一步都做的比小文更好,这就是对被代理对象方法的增强
3、场景
面向切面编程中就用到了代理模式,具体的内容后面有机会再详细介绍吧
二、静态代理
1、代码
我们用静态代理来实现上面例子
定义接口:无论是谁进行劳动仲裁,都需要按着这个流程执行
public interface ArbitrationStep {
/**
* 准备仲裁申请
*/
void prepareApp();
/**
* 收集证据
*/
void collectEvi();
/**
* 开庭答辩
*/
void debate();
}
定义被代理类
public class XiaoWen implements ArbitrationStep {
@Override
public void prepareApp() {
System.out.println("准备仲裁申请!");
}
@Override
public void collectEvi() {
System.out.println("收集证据!");
}
@Override
public void debate() {
System.out.println("开庭答辩!");
}
}
定义代理类
可以看到代理类中不仅执行了被代理的方法,同时还对其方法进行了一定的增强
public class LawyerProxy implements ArbitrationStep {
private XiaoWen xiaoWen;
public LawyerProxy(XiaoWen xiaoWen) {
this.xiaoWen = xiaoWen;
}
@Override
public void prepareApp() {
System.out.println("律师听取小文的想法");
xiaoWen.prepareApp();
System.out.println("律师对申请进行修改");
}
@Override
public void collectEvi() {
xiaoWen.collectEvi();
System.out.println("律师对证据进行整理");
}
@Override
public void debate() {
xiaoWen.debate();
System.out.println("律师更详细的阐述");
}
}
测试类
public class Tribunal {
public static void main(String[] args) {
XiaoWen xiaoWen = new XiaoWen();
System.out.println("小文委托律师帮忙进行劳动仲裁");
LawyerProxy proxy = new LawyerProxy(xiaoWen);
System.out.println("-------第一步-------");
proxy.prepareApp();
System.out.println("-------第二步-------");
proxy.collectEvi();
System.out.println("-------第三步-------");
proxy.debate();
System.out.println();
System.out.println("仲裁结束");
}
}
运行结果
小文委托律师帮忙进行劳动仲裁
-------第一步-------
律师听取小文的想法
准备仲裁申请!
律师对申请进行修改
-------第二步-------
收集证据!
律师对证据进行整理
-------第三步-------
开庭答辩!
律师更详细的阐述
仲裁结束
2、总结
通过上面的代码可以总结出静态代理的步骤
- 定义接口
- 被代理类和代理类都需要实现该接口
- 定义被代理类
- 实现上面定义的接口
- 定义代理类
- 实现上面定义的接口
- 创建被代理对象
- 调用方法时需要调用被代理对象的方法,同时自己可以对方法进行增加
图解
3、存在的问题
如果一个类需要被代理,就得去创建一个代理类。如果被代理的类过多,这样就需要手动创建很多代理类。为了解决这个问题,便有了动态代理
三、基于Java反射的动态代理
1、反射与类加载
同时还可以参考知乎回答——Java 动态代理作用是什么?(膜拜大佬啊!)
2、使用反射实现动态代理
接着上面的劳动仲裁的例子,不过这次我们用动态代理去实现
但是需要用到Proxy类的两个静态方法
- getProxyClass
- 这个方法, 会从你传入的接口Class中,“拷贝”类结构信息到一个新的Class对象中,但新的Class对象带有构造器,是可以创建对象的
- newProxyInstance(一般直接用这个)
- 封装了得到代理类Class对象、构造函数等细节,直接返回了代理对象
接口和被代理类不变
public interface ArbitrationStep {
/**
* 准备仲裁申请
*/
void prepareApp();
/**
* 收集证据
*/
void collectEvi();
/**
* 开庭答辩
*/
void debate();
}
public class XiaoWen implements ArbitrationStep {
@Override
public void prepareApp() {
System.out.println("准备仲裁申请!");
}
@Override
public void collectEvi() {
System.out.println("收集证据!");
}
@Override
public void debate() {
System.out.println("开庭答辩!");
}
}
通过反射获得代理对象
public class Tribunal2 {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
// 获取代理类的Class对象
Class<?> proxyClazz = Proxy.getProxyClass(ArbitrationStep.class.getClassLoader(), ArbitrationStep.class);
// 获得构造函数
Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);
// 创建代理对象
ArbitrationStep lawyerProxy = (ArbitrationStep) constructor.newInstance(new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 创建被代理对象,用于调用方法
XiaoWen xiaoWen = new XiaoWen();
// 通过invoke方法调用了被代理对象的方法
Object invoke = method.invoke(xiaoWen, args);
// 每个步骤都让律师帮忙处理
System.out.println("律师帮忙处理!");
return invoke;
}
});
// 通过代理对象调用方法
System.out.println("-------第一步-------");
lawyerProxy.prepareApp();
System.out.println("-------第二步-------");
lawyerProxy.collectEvi();
System.out.println("-------第三步-------");
lawyerProxy.debate();
System.out.println();
System.out.println("仲裁结束");
}
}
运行结果
-------第一步-------
准备仲裁申请!
律师帮忙处理!
-------第二步-------
收集证据!
律师帮忙处理!
-------第三步-------
开庭答辩!
律师帮忙处理!
仲裁结束
自己封装获得代理对象的方法
public class Tribunal3 {
public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
XiaoWen xiaoWen = new XiaoWen();
// 获得代理对象
ArbitrationStep lawyerProxy = (ArbitrationStep) getProxy(xiaoWen);
// 通过代理对象调用方法
System.out.println("-------第一步-------");
lawyerProxy.prepareApp();
System.out.println("-------第二步-------");
lawyerProxy.collectEvi();
System.out.println("-------第三步-------");
lawyerProxy.debate();
System.out.println();
System.out.println("仲裁结束");
}
// 该方法返回一个代理对象
public static Object getProxy(Object target) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// target为被代理对象,得到其代理类的Class对象
Class<?> proxyClazz = Proxy.getProxyClass(target.getClass().getClassLoader(), target.getClass().getInterfaces());
// 获得构造函数
Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);
// 获得代理对象
Object targetProxy = constructor.newInstance(new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = method.invoke(target, args);
System.out.println("代理类增强方法");
return invoke;
}
});
return targetProxy;
}
}
我们自己编写了一个getProxy方法,传入被代理的对象,返回一个代理对象。
通过newProxyInstance()获得代理对象
上面的getProxy方法返回代理对象的过程是我们自己写的,通过Proxy类的newProxyInstance()可以直接返回代理对象
public static Object getProxyByProxyMethod(Object target) {
// 直接返回代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = method.invoke(target, args);
System.out.println("代理对象增强方法");
return invoke;
}
});
}
看看newProxyInstance帮我们做了些什么工作
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
// 下面这一段其实就是getProxyClass方法的内部实现
// --------------------------------------------------------------
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
// 获得接口加上构造函数后的Class对象
Class<?> cl = getProxyClass0(loader, intfs);
// ----------------------------------------------------------------
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// 获得构造函数
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
// 返回代理对象
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
我们自己获取代理对象的步骤是
- 通过getProxyClass获得代理对象的Class对象(接口+对应的构造函数)
- 通过Class对象调用得到构造方法
- 构造方法去创建实例
- 构造方法传入InvocationHandler实例,需要实现其invoke方法
newProxyInstance帮我们获取代理的步骤和上面类似,只不过Class对象是直接通过getProxyClass0(loader, intfs)来获取的。而我们自己封装的代码中,使用的是getProxyClass方法。但是该方法最终还是调用的getProxyClass0(loader, intfs)来获取的Class对象
getProxyClass方法
public static Class<?> getProxyClass(ClassLoader loader,
Class<?>... interfaces)
throws IllegalArgumentException
{
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
return getProxyClass0(loader, intfs);
}
newProxynewInstance方法的前面部分的代码
3、如何实现方法增强
上面的例子确实将被代理对象的方法增强了,但这是如何实现的呢
InvocationHandler
我们在获得代理类构造器的时候,传入了InvocationHandler
Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);
InvocationHandler是一个接口,内部只有一个方法invoke
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
在通过constructor获取代理对象时,newInstance方法需要传入一个invocationHandler的实例,这个实例重写了invoke方法,就是通过它代理对象增强了被代理对象的方法
Object targetProxy = constructor.newInstance(new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 调用被代理对象的对应方法
// target 被代理对象
// args 方法需要的参数
Object invoke = method.invoke(target, args);
System.out.println("代理类增强方法");
return invoke;
}
});
return targetProxy;
}
图解
总结
调用代理对象的方法时,实际上调用的是InvocationHandler的invoke方法,这个方法内部不仅调用了被代理对象的方法,还可以增加其他功能
4、为什么必须实现接口
通过
lawyerProxy.getClass().getSuperclass()
可以获得代理对象的父类,可以看到其父类为
class java.lang.reflect.Proxy
也就是无论是什么代理类,都会继承自Proxy,而Java又是单继承的,所以想要被代理对象与代理对象产生联系,就只能通过接口来实现了
四、基于CGLib的动态代理
Java动态代理是面向接口的代理模式,如果没有接口,但是想要去实现动态代理,就需要用到CGLib来进行动态代理了
CGLib是一个强大、高性能的Code生产类库,可以实现运行期动态扩展java类
1、使用CGLib实现动态代理
被代理的类
public class XiaoWen {
public void prepareApp() {
System.out.println("准备仲裁申请");
}
public void collectEvi() {
System.out.println("收集证据");
}
public void debate() {
System.out.println("开庭辩论");
}
}
自定义拦截器实现MethodInterceptor接口
public class LawyerInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
// 前置增强
System.out.println("律师给出建议");
// 被代理类执行的方法(被增强的方法)
// 注意这里是调用invokeSuper而不是invoke,否则死循环;
// methodProxy.invokeSuper执行的是原始类的方法;
// method.invoke执行的是子类的方法;
Object invoke = methodProxy.invokeSuper(o, objects);
// 后置增强
System.out.println("律师帮忙");
return invoke;
}
}
使用Enhancer创建代理对象
public class Main {
public static void main(String[] args) {
// 创建增强器
Enhancer enhancer = new Enhancer();
// 传入被代理的Class对象(作为代理对象的父类)
enhancer.setSuperclass(XiaoWen.class);
// 设置回调函数,传入自定义的拦截器
enhancer.setCallback(new LawyerInterceptor());
// 获取代理对象
XiaoWen proxy = (XiaoWen) enhancer.create();
System.out.println("小文委托律师帮忙进行劳动仲裁");
System.out.println("-------第一步-------");
proxy.prepareApp();
System.out.println("-------第二步-------");
proxy.collectEvi();
System.out.println("-------第三步-------");
proxy.debate();
System.out.println();
System.out.println("仲裁结束");
}
}
运行结果
小文委托律师帮忙进行劳动仲裁
-------第一步-------
律师给出建议
准备仲裁申请
律师帮忙
-------第二步-------
律师给出建议
收集证据
律师帮忙
-------第三步-------
律师给出建议
开庭辩论
律师帮忙
仲裁结束
2、CGLib实现原理
CGLib可以为没有实现接口的类创建代理类。其原理是CGLib底层使用了ASM框架,该框架可以通过修改字节码,来创建一个被代理类的子类,也就是代理类。并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。这种思想符合里氏替换原则,即子类可以扩展父类的功能,但是不能改变父类原有的功能。
代理类的父类
就上面的例子,我们通过
proxy.getClass().getSuperclass();
来获取代理类的父类,可以看到其父类是
class com.nyima.study.day01.XiaoWen
也就是我们的被代理类,这也从一定程度上说明自定义拦截器在调用被拦截对象的方法时,需要调用
Object invoke = methodProxy.invokeSuper(o, objects);
本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!