静态代理

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.happyMarry();
    }
}

interface Marry{
    /**
     * 结婚
     */
    void happyMarry();
}

/**
 * 真实角色：你去结婚
 */
class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("我要结婚了，超开心！");
    }
}

/**
 * 代理角色：帮助你结婚
 */
class WeddingCompany implements Marry{
    /** 代理真实角色：目标对象 **/
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void happyMarry() {
        before();
        // 真实对象
        this.target.happyMarry();
        after();
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }

    private void after() {
        System.out.println("结婚之后，收尾款");
    }
}

结婚之前，布置现场
我要结婚了，超开心！
结婚之后，收尾款

Process finished with exit code 0

• 真实对象和代理对象都要实现同一个接口。
• 代理对象要代理真实角色。
• 代理对象可以做很多真实对象做不了的事情。
• 真实对象专注做自己的事情。

静态代理和线程的对比

public class StaticProxy {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("我爱你");
        }).start();

        new WeddingCompany(new You()).happyMarry();
    }
}

发现实现Runnable接口创建线程的启动，底层原理就是静态代理。