代理模式从业务上讲其实还是比较好理解的，比如过年我想买一张火车票，总也买不到，怎么办？

比如可以让男朋友去火车站排队去买！这叫静态代理

一、静态代理

首先我们定义一个接口，买火车票

public interface BuyTicket {
    public void buy();
}

然有个美女，想要回家，需要买一张火车票

public class BuyTicketGirl implements BuyTicket {
    @Override
    public void buy() {
        System.out.println("I need a ticket");
    }
}

很遗憾，过年的时候火车票不好买，美女只好求男朋友去帮忙买

public class BuyTicketBoy implements BuyTicket {

    private BuyTicket buyTicket;

    public BuyTicketBoy(BuyTicket buyTicket) {
        this.buyTicket = buyTicket;
    }

    @Override
    public void buy() {
        System.out.println("I am boy friend");
        buyTicket.buy();
    }
}

public class Main {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicketGirl();
        BuyTicket proxy = new BuyTicketBoy(buyTicket);
        proxy.buy();
}
}

买到了，输出：

I am boy friend
I need a ticket

很好，但这有一个问题，如果让男朋友帮忙买票，前提是每个人都有男朋友，显然这并不现实。

这也是静态代理的缺点：代理只能为一个类服务，如果需要为很多类服务，需要写很多代理类，这并不是我们想看到的。

那怎么办？

如果你去过火车站，会发现火车站就会有一些到处晃悠的大哥悄没声问：买票不？

对于买票这个行为来说，他的身份就是代理，他能帮我完成买票这个行为，具体他是谁，怎么做到，我不关心。

而且在买票这个事上，他能帮很多人实现梦想。这就是动态代理。

二、动态代理

首先我们先实现一个买票大哥，他持有一个object属性，意味他可以为所有人帮忙买票，如果你需要，说不定还可以帮忙买房买车。

public class ProxyHandler implements InvocationHandler {

    private Object object;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("I am Dynamic Proxy");
        method.invoke(object,args);
        return null;
    }
}

开始买票

public class Main {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicketGirl();

        ProxyHandler proxyHandler = new ProxyHandler(buyTicket);
        BuyTicket proxyInstance = (BuyTicket) Proxy.newProxyInstance(
                buyTicket.getClass().getClassLoader(),
                buyTicket.getClass().getInterfaces(),
                proxyHandler);

        proxyInstance.buy();
}
}

输出：

I am Dynamic Proxy
I need a ticket

也买到票了，这就是动态代理