什么是代理模式?
其实和生活中的“代理商”,“代理人”意思是一样的。简单来说,就是自己想做的事情,因为某些原因无法直接做,必须交由其他人“代理”来实现。例子很多,就不举例子了。重点是要明白它能够做些什么,以及怎么做的。至于什么时候用,得由自己判断。
静态代理
我们先通过一个静态代理的简单示例,初步了解代理模式。
情景:就好比猎头给公司招人。公司是招人的”真实角色”,猎头是负责招人的“代理角色”。
代理内容抽象为接口
公司和猎头需要共同约定,猎头负责代理的范围(具体做哪些事情)。
/**
* 描述:定义代理的具体内容
* <p>作者: aliyu
* <p>创建时间: 2021-10-15 10:44 上午
*/
public interface HireSomeone {
/**
* 雇佣
*/
public void hire();
}
真实角色
真正处理请求的角色——公司。代理内容接口,最终是要公司自己去实现的。
/**
* 描述:公司招聘,实际招聘人
* <p>作者: aliyu
* <p>创建时间: 2021-10-15 10:37 上午
*/
public class CompanyHire implements HireSomeone{
@Override
public void hire() {
System.out.println("我是实际执行雇佣的人");
}
}
代理角色
代理角色内部含有真实对象的引用,从而可以将请求转为真实对象处理,同时可以在前后附加操作(举个例子:找工作的人同意入职了,猎头需要给ta发录取邮件。这个操作,猎头实际是不能处理的。所以猎头需要拉上具体公司的hr,由hr完成这个操作。同时猎头作为中间人,是可以对双方往来加一些东西的)。
/**
* 描述:代理角色
* <p>作者: aliyu
* <p>创建时间: 2021-10-15 10:54 上午
*/
public class ProxyHire implements HireSomeone{
/**
* 传入实际操作的角色“公司”
*/
private CompanyHire companyHire;
public ProxyHire(CompanyHire companyHire) {
this.companyHire = companyHire;
}
@Override
public void hire() {
//实际操作是由真实角色“公司”完成的
companyHire.hire();
}
}
测试代理对象完成代理:
/**
* 描述:模拟通过调用代理对象,实际调用真实对象的过程
* <p>作者: aliyu
* <p>创建时间: 2021-10-15 10:57 上午
*/
public class TestProxy {
public static void main(String[] args) {
//实例化"实际对象"
CompanyHire companyHire = new CompanyHire();
//传入"代理"
ProxyHire proxyHire = new ProxyHire(companyHire);
//点进去看代码,可以发现"雇佣"操作实际是由传入"真实对象"完成的。
proxyHire.hire();
}
}
动态代理
每一个代理类都必须实现一遍代理内容接口,如果接口增加方法,则代理类也必须跟着修改。其次,代理类每一个接口对象对应一个真实对象,如果真实对象非常多,则静态代理类就非常臃肿,难以胜任。如下图:
public class ProxyHire implements HireSomeone{
private CompanyHire companyHire;
......
public class ProxyHire2 implements HireSomeone{
private CompanyHire2 companyHire2;
......
public class ProxyHire3 implements HireSomeone{
private CompanyHire3 companyHire3;
......
同时,我们也可以发现,这样的代码其实是重复的。有没有办法不去写这么多代理类呢?这就要提到动态代理了。
动态代理有别于静态代理,是根据代理的对象,动态创建代理类。这样,就可以避免静态代理中代理类过多的问题。动态代理是实现方式,是通过反射来实现的,借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。
new一个动态代理类:
/**
* 描述:动态代理类
* <p>作者: aliyu
* <p>创建时间: 2021-10-15 2:09 下午
*/
public class DynamicProxyHire implements InvocationHandler {
/**
* 传入的是object,就可以满足不同真实对象的传入
*/
private Object object;
public DynamicProxyHire(Object object) {
this.object = object;
}
/**
* 当在与其关联的代理实例上调用方法时,将在调用处理程序上调用此方法。
* 简单来说就是通过动态代理类执行真实对象方法时,会进入这里。
* @param proxy 真实对象
* @param method 通过代理对象调用的方法(通过反射获得)
* @param args 参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//调用真实对象的方法
Object result = method.invoke(this.object, args);
return result;
}
}
测试通过动态代理对象完成代理
public class TestDynamicProxy {
public static void main(String[] args) {
//我们要代理的真实对象
CompanyHire companyHire = new CompanyHire();
//我们要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法的
InvocationHandler handler = new DynamicProxyHire(companyHire);
//第一个参数 ,我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
ClassLoader classLoader = handler.getClass().getClassLoader();
//第二个参数,我们这里为代理对象提供的接口是真实对象所实现的接口,表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了
Class<?>[] interfaces = companyHire.getClass().getInterfaces();
//第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
//表示当前的InvocationHandler实现实例对象
HireSomeone hireSomeone = (HireSomeone) Proxy.newProxyInstance(classLoader, interfaces, handler);
hireSomeone.hire();
}
}
代理模式优缺点
优点1-延迟加载
“在系统启动时,将消耗资源最多的方法都使用代理模式分离,就可以加快系统的启动速度,减少用户的等待时间。而在用户真正的查询
操作时,再由代理类,单独去加载真实的数据库查询类,完成用户的请求,这个过程就是使用了代理模式现实了延迟加载”——理论是可以理解的,但是具体如何实现的呢?找了一个例子。
抽象代理接口:
真实角色:
代理角色:
ps:原来只用把传入的真实对象 = null ,就可以了。然后真正调用方法时,再去实例化真实对象。这样就起到了延迟加载的作用。
例子网址:https://www.cnblogs.com/klyjb/p/11522968.html
优点2-降低耦合和便于维护
检验工作在调用真实对象前做。如果新增了功能,可以不修改真实对象,而修改代理对象。对象聚合代替继承,降低耦合。
所谓“检验工作可以在调用真实对象前做”,是因为它是代理对象方法里面去调用真实对象的方法,在上面加几行校验代码不是什么难事。
@Override
public void hire() {
//这里可以加入校验代码
//实际操作是由真实角色完成的
companyHire.hire();
//执行完后也可以加入代码,实现某些特殊的需求
}
“如果新增了功能,可以不修改真实对象,而修改代理对象。”——这句话,大概也是和调用真实对象前添加校验,是一样的,不过是加的内容不同。
总之,可以这样做,但这样的场景没有遇到,说不清楚。
缺点
每一个代理类都必须实现一遍代理内容接口,如果接口增加方法,则代理类也必须跟着修改。