什么是代理模式？
其实和生活中的“代理商”，“代理人”意思是一样的。简单来说，就是自己想做的事情，因为某些原因无法直接做，必须交由其他人“代理”来实现。例子很多，就不举例子了。重点是要明白它能够做些什么，以及怎么做的。至于什么时候用，得由自己判断。
静态代理
我们先通过一个静态代理的简单示例，初步了解代理模式。
情景：就好比猎头给公司招人。公司是招人的”真实角色”，猎头是负责招人的“代理角色”。
代理内容抽象为接口
公司和猎头需要共同约定，猎头负责代理的范围（具体做哪些事情）。
/**
* 描述：定义代理的具体内容
* <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();
//执行完后也可以加入代码，实现某些特殊的需求
}
“如果新增了功能，可以不修改真实对象，而修改代理对象。”——这句话，大概也是和调用真实对象前添加校验，是一样的，不过是加的内容不同。
总之，可以这样做，但这样的场景没有遇到，说不清楚。
缺点
每一个代理类都必须实现一遍代理内容接口，如果接口增加方法，则代理类也必须跟着修改。