静态代理

静态代理，简单理解就是：代理对象代理真实角色去做真实对象做不了的事情 

静态代理模式总结：

1. 真实对象和代理对象都要实现同一个接口
2. 代理对象要代理真实角色

好处：

1. 代理对象可以做很多真实对象做不了的事（比如下面示例中的before(),after()）
2. 真实对象专注做自己的事情(结婚) 

一个典型的代理模式通常有三个角色，这里称之为代理三要素

1.共同接口

//1.共同接口   结婚接口
interface Marry{
    void HappyMarry();//接口里的方法都是抽象的，没有方法体
}

2.真实对象

//2.真实对象  实现结婚接口  真实角色  我去结婚
class Me implements Marry{
    @Override
    public void HappyMarry(){
        System.out.println("我要结婚啦，超开心！");
    }
}

3.代理对象 

//3.代理对象   婚庆公司  代理真实角色  帮助你结婚
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("结婚之后，婚庆公司收尾款");
    }
}

结婚示例：我要结婚，婚庆公司代理我去布置现场等

上代码：

package com.kuang.thread;


/**
 * @ClassName TestThread6
 * @Description 静态代理
 * @Author 麻虾
 * @Date 2021/4/25 14:40 40
 * @Version 1.0
 */

//深度剖析一下Thread类

//以结婚为例，演示什么叫静态代理模式

//1.共同接口   结婚接口
interface Marry{
    void HappyMarry();//接口里的方法都是抽象的，没有方法体
}

//2.真实对象  实现结婚接口  真实角色  我去结婚
class Me implements Marry{
    @Override
    public void HappyMarry(){
        System.out.println("我要结婚啦，超开心！");
    }
}

//3.代理对象   婚庆公司  代理角色  帮助你结婚
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("结婚之后，婚庆公司收尾款");
    }
}

public class StaticProxy {

    public static void main(String[] args) {

//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//
//            }
//        }).start();

        //比较Thread与静态代理
        //用lamda表达式简化

        new Thread( ()-> System.out.println("我爱你") ).start();

        new WeddingCompany(new Me()).HappyMarry();//把下面代码简化成这一句
        
//        Me me = new Me();//你要结婚
//
//        WeddingCompany weddingCompany = new WeddingCompany(me);
//        WeddingCompany weddingCompany = new WeddingCompany(new Me());
//        weddingCompany.HappyMarry();

    }

}

通过静态代理，深度剖析一下线程Thread类

创建一个线程对象并启动：

    new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();

 我们使用Lamda表达式将上面代码简化为：

    //用lamda表达式简化

    new Thread( ()-> System.out.println("我爱你") ).start();

 与静态代理比较：

    new WeddingCompany(new Me()).HappyMarry();//把下面代码简化成这一句
        
//    Me me = new Me();//你要结婚
//    WeddingCompany weddingCompany = new WeddingCompany(me);
//    WeddingCompany weddingCompany = new WeddingCompany(new Me());
//    weddingCompany.HappyMarry();

 

比较静态代理与Thread类的关系：

• Thread类其实也是一个代理，通过源码知道，Thread类也是实现了Runnable接口
• Thread代理的是里面的Lamda表达式，也就是Runnable接口，然后调用的start()方法
• WeddingCompany是一个代理，代理的是真实角色Me，然后调用HappyMarry()方法，相当于start())方法

        其实静态代理就是Thread线程的底层的实现原理