java设计模式之代理

其实和生活中的“代理商”，“代理人”意思是一样的。简单来说，就是自己想做的事情，因为某些原因无法直接做，必须交由其他人“代理”来实现。例子很多，就不举例子了。重点是要明白它能够做些什么，以及怎么做的。至于什么时候用，得由自己判断。

我们先通过一个静态代理的简单示例，初步了解代理模式。
情景：就好比猎头给公司招人。公司是招人的”真实角色”，猎头是负责招人的“代理角色”。

公司和猎头需要共同约定，猎头负责代理的范围（具体做哪些事情）。

public interface HireSomeone {

    
    public void hire();
}

真正处理请求的角色——公司。代理内容接口，最终是要公司自己去实现的。

public class CompanyHire implements HireSomeone{

    @Override
    public void hire() {
        System.out.println("我是实际执行雇佣的人");
    }
}

代理角色内部含有真实对象的引用，从而可以将请求转为真实对象处理。同时可以在前后附加操作。

public class ProxyHire implements HireSomeone{

    
    private CompanyHire companyHire;

    public ProxyHire(CompanyHire companyHire) {
        this.companyHire = companyHire;
    }

    @Override
    public void hire() {
        //实际操作是由真实角色“公司”完成的
        companyHire.hire();
    }
}

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,通过固定的规则生成。

public class DynamicProxyHire implements InvocationHandler {

    
    private Object object;

    public DynamicProxyHire(Object object) {
        this.object = object;
    }

    
    @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();
    }
}

“在系统启动时，将消耗资源最多的方法都使用代理模式分离，就可以加快系统的启动速度，减少用户的等待时间。而在用户真正的查询
操作时，再由代理类，单独去加载真实的数据库查询类，完成用户的请求，这个过程就是使用了代理模式现实了延迟加载”——理论是可以理解的，但是具体如何实现的呢？找了一个例子。

抽象代理接口：

真实角色：

代理角色：

ps：原来只用把传入的真实对象 = null ，就可以了。然后真正调用方法时，再去实例化真实对象。这样就起到了延迟加载的作用。
例子网址：https://www.cnblogs.com/klyjb/p/11522968.html

检验工作在调用真实对象前做。如果新增了功能，可以不修改真实对象，而修改代理对象。对象聚合代替继承，降低耦合。

所谓“检验工作可以在调用真实对象前做”，是因为它是代理对象方法里面去调用真实对象的方法，在上面加几行校验代码不是什么难事。

    @Override
    public void hire() {
        //这里可以加入校验代码
        //实际操作是由真实角色完成的
        companyHire.hire();
        //执行完后也可以加入代码，实现某些特殊的需求
    }

“如果新增了功能，可以不修改真实对象，而修改代理对象。”——这句话，大概也是和调用真实对象前添加校验，是一样的，不过是加的内容不同。
总之，可以这样做，但这样的场景没有遇到，说不清楚。

每一个代理类都必须实现一遍代理内容接口，如果接口增加方法，则代理类也必须跟着修改。