设计模式之静态代理模式

静态代理模式（设计模式）

举个例子：以结婚为例，现在结婚都要找婚庆公司去处理，这其实就是一个代理模式的使用。

你：真实结婚角色

婚庆公司：代理你，帮你处理结婚的事情

结婚：实现结婚接口即可

代码实现：

package com.lwq.staticProxy;

/**
 * 静态代理模式总结：
 * 1、真实对象和代理对象都要事先同一个接口
 * 2、代理对象要代理真实角色
 * 
 * 静态代理模式优点（为什么要使用）：
 * 1、代理对象可以做很多真实对象做不了的事情
 * 2、真实对象就可以做自己专注的功能
 * 实际上在spring的切面AOP上就大量使用代理模式对真实对象进行前后置的增强
 */
public class StaticProxy {
    public static void main(String[] args) {
        //本次客户是lwq先生
        You lwq = new You("lwq");
        //代理类帮你做事，这样就把真实类和那个实际的结婚接口解耦了，后面方便面向接口编程，容易扩展，而不影响真实的类
        WeddingCompany weddingCompany = new WeddingCompany(lwq);
        weddingCompany.happyMarry();

    }
}

//定义一个结婚的接口，面向接口的编程，有约束性
interface Marry{
    void happyMarry();
}

//实现类，你本人要结婚
class You implements  Marry{
    //客户姓名
    private String name;
    //有参构造
    public You(String name) {
        this.name = name;
    }
    //无参构造
    public You() {

    }
    public void happyMarry() {
        System.out.println(this.name + "要结婚了。");
    }
}

class WeddingCompany implements Marry{
    //接到办理的客户
    private You you;
    //构造函数，办理一次婚礼的时候把客户传进去，这也是现实到逻辑的转换
    public WeddingCompany(You you) {
        this.you = you;
    }

    public void happyMarry() {
        before();
        System.out.println("婚庆公司负责办理您的婚礼，让您免除一切烦恼，专门结婚就行。");
        after();
    }
    //对被代理类的前置增强
    public void before(){
        System.out.println("婚前布置婚礼现场。");
    }
    //被代理类的前置增强
    public void after(){
        System.out.println("婚后数份子钱。");
    }
}

我们来看一下线程和代理之间的一个联系

public static void main(String[] args) {
    
    //代理模式的=========================================
    
    //本次客户是lwq先生
    You lwq = new You("lwq");
    //代理类帮你做事，这样就把真实类和那个实际的结婚接口解耦了，后面方便面向接口编程，容易扩展，而不影响真实的类
    WeddingCompany weddingCompany = new WeddingCompany(lwq);
    weddingCompany.happyMarry();

	 //多线程的=========================================
    //创建Runnable接口的实现类
    TestRunnable02 tr = new TestRunnable02();
    //创建线程对象，通过线程对象启动子线程，这里涉及一个代理模式
    Thread th = new Thread(tr);
    //启动线程
    th.start();
}

我们看到多线程的和代理模式的一模一样的一个模式，其实多线程这里就是用代理模式设计的，Thread点进去看源码就知道它本质还是实现了Runnable接口，接口里的结婚方法就是run方法，然后Thread是那个代理类，Thread里面对Runnable接口其实是有一些扩展的，所以你知道为什么要推荐这种多线程方式了吧，其实就是代理模式容易扩展，而且解开了真实用户和实际实现的一定程度的耦合。