java中的静态代理

代理的概念：为某个对象提供代理，以控制对这个对象的访问。
代理的模型图：

代理接口：声明代理对象和真实对象的接口。
真实对象：实现代理接口的对象，最终存在于代理对象内部，代理对象拦截到的方法会调用真实对象中的方法。
代理对象：内部含有真实对象，也实现了代理接口，在实现接口的时候会调用真实对象中的方法，同时会也附加了新的操作。

给出一个Demo帮助理解这三个类之间的关系：

//代理接口
package com.zhangyike.staticProxy;

public interface Person {
    public void eat();

    public void study();

    public void play();
}

//真实对象
package com.zhangyike.staticProxy;

/*
 * 真实对象
 */
public class RealPerson implements Person {
    @Override
    public void eat() {
        System.out.println("真实对象中吃。");
    }

    @Override
    public void study() {
        System.out.println("真实对象中学习。");
    }

    @Override
    public void play() {
        System.out.println("真实对象中玩耍。");
    }
}

//代理对象
package com.zhangyike.staticProxy;

/*
 * 代理对象
 */
public class ProxyPerson implements Person {
    // 代理对象中含有真实对象
    private RealPerson realPerson;

    @Override
    public void eat() {
        perRequest();

        if (null == realPerson) {
            realPerson = new RealPerson();
        }
        // 调用真实对象的该方法
        realPerson.eat();

        afterRequest();
    }

    private void afterRequest() {
        System.out.println("在真实对象操作之后附加操作...");

    }

    private void perRequest() {
        System.out.println("在真实对象操作之前附加操作....");

    }

    @Override
    public void study() {
        perRequest();

        if (null == realPerson) {
            realPerson = new RealPerson();
        }
        // 调用真实对象的该方法
        realPerson.study();

        afterRequest();

    }

    @Override
    public void play() {
        perRequest();

        if (null == realPerson) {
            realPerson = new RealPerson();
        }
        // 调用真实对象的该方法
        realPerson.study();

        afterRequest();
    }
}

//demo类
package com.zhangyike.staticProxy;

public class DemoTest {
    public static void main(String[] args) {
        ProxyPerson proxy = new ProxyPerson();

        proxy.eat();
        System.out.println();

        proxy.study();
        System.out.println();

        proxy.play();
        System.out.println();
    }
}

运行结果：
在真实对象操作之前附加操作….
真实对象中吃。
在真实对象操作之后附加操作…

在真实对象操作之前附加操作….
真实对象中学习。
在真实对象操作之后附加操作…

在真实对象操作之前附加操作….
真实对象中学习。
在真实对象操作之后附加操作…

从上述例子可以看出：
在程序运行前，代理类和真实类的关系就已经存在了，他们所运行的字节码文件就已经存在了，代理接口中的方法必须在真实对象和代理对象中分别实现。

总结：
静态代理的优点：客户端不需要知道实现类是什么，具体的操作是什么，只需要知道代理对象，调用所需要的方法即可。就像上述例子，用户只要调用ProxyPerson中的方法即可。
静态代理的缺点：
1.真实类和代理类实现了相同的接口，代理类通过真实类实现了相同的方法，并对其方法进行增强，这样使大量的代码在重复。如果接口中的方法相当多，而代理类只对个别方法进行了增强的操作，那么在代理类中实现接口中的方法仅仅是对真实类中方法的调用，增加了代码的维护性。
2.代理类只能服务于一个代理接口，如果服务于多类型的对象，势必对每个对象进行代理，静态代理的规模是无法承受的。

因为静态代理中一个代理类只能代理一个接口，多个接口需要多个代理类来实现。所以我们需要用一个代理类对所以接口进行管理，所以采用动态代理的方式，用反射机制对各个类型的对象进行代理。

动态代理请看前两篇文章….