静态代理

静态代理

今天我们来聊一聊线程底部的实现原理，主要是通过演示实现静态代理，来对比继承Thread类。

案例：结婚

A.人：真实角色；

B.婚庆公司：帮你处理结婚的一些事，例如：布置现场等；

C.结婚：实现结婚接口即可，这就需要造一个结婚接口。

代码及说明如下：

public class StaticProxy {
    public static void main(String[] args) {
        //先new出一个代理(婚庆公司)
        WeddingCompany weddingCompany = new WeddingCompany(new Person("小明"));
        weddingCompany.HappyMarry();
        //并没有通过人直接调用结婚方法，而是通过婚庆公司来代理结婚，但是实际上还是主角（人）完成了结婚；

        //将前两段代码和下面的代码对比一下：
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我要结婚啦");
            }
        }).start();
        //可以得出一下结论：
        //Thread类就相当于上面的WeddingCompany类,都扮演代理的角色；
        //他们都代理真实对象，Thread类代理了Runnable接口
        //因为Thread类也实现了Runnable接口；
        //因此，Thread类代理了真实的Runnable接口，调用了start()方法；
        //就好比，婚庆公司代理了真实的人，调用了结婚方法HappyMarry()；
        //相当于线程里面调用start()方法；

        //不采用代理方式：
        Person person = new Person("小丽");
        person.HappyMarry();
    }
}

interface Marry {
    void HappyMarry();
}

//人：真实角色
class Person implements Marry {

    private String personName;

    //在new对象时，需要传入结婚的角色的姓名；
    public Person(String personName) {
        this.personName = personName;
    }

    @Override
    public void HappyMarry() {
        System.out.println(this.personName + "结婚了，很开心！");
    }
}

//婚庆公司：代理角色，帮助你结婚
class WeddingCompany implements Marry {

    //这就是真实角色（目标）；
    private Marry targetPerson;

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

    @Override
    public void HappyMarry() {
        //结婚前
        beforeMarry();
        //结婚
        this.targetPerson.HappyMarry();
        //结婚后
        afterMarry();
    }
    private void beforeMarry() {
        System.out.println("结婚前，布置现场");
    }
    private void afterMarry() {
        System.out.println("结婚后，结尾款");
    }
}

静态代理模式总结：

1.真实对象和代理对象都要实现同一个接口；
2.代理对象要代理真实角色，因此必须把真实角色传进去（通过构造方法）；
3.好处：
A.代理对象可以做许多真实对象做不了或不想做的事情；
B.而真实对象只需要专注的做自己的事情（无法被替代的事情）；

通过以上的静态代理模式的学习，我们了解了线程底部的实现原理（代理）。