1、引言

本文主要是分析Spring框架中使用到的哪些设计模式，我们都知道无论是SpringMVC、SpringBoot、SpringCloud这些框架的核心都是Spring，本篇文章就结合一些源码以及测试的例子讲解Spring框架中使用的设计模式。

相关代码请参考: chapter-4-springmvc-sourcecode-analysis


https://gitee.com/leo825/spring-framework-learning-example.git

2、Spring常用的设计模式（先留坑，慢慢补充）

2.1 简单工厂模式

Spring中用到的简单工厂模式就是我们经常用到的BeanFactory。

2.2 工厂方法模式

Spring中用到的工厂方法模式就是FactoryBean。

2.3 适配器模式

Spring中的拦截器就用到了适配器模式。

2.4 装饰器模式（包装器模式）

Spring中的各种Wrapper和Decorator就用到了装饰器模式。

2.5 代理模式

Spring中的AOP就用到了代理模式，代理模式有两种实现：JDK动态代理、Cglib动态代理。

2.6 观察者模式

Spring中的ApplicationListener就用到了观察者模式。Spring中使用的观察者最多的就是通过事件响应方式。以下是简单举一个观察者实现的例子:

业务场景：订单订购成功之后，

1、需要调用订单同步接口

2、需要调用计费同步接口

3、需要调用订单审核接口等等

以往的写法写一个同步大方法： 订单同步方法 -> 计费同步方法 ->订单审核方法 等等。

现在换一种思路，通过事件响应的方式，如果完成了订购之后可以通过观察者通知的方式，继续以后的操作。

具体步骤如下：

2.6.1、先定义一个Event

首先，定义一个事件的接口。

public interface Event extends Serializable{

    /**
     * 设置事处理对象
     * @param eventObject
     */
    void setEventObject(EventObject eventObject);

    EventObject getEventObject();
}

其中事件的对象如下：

/**
 * @ClassName: EventObject
 * @Description: 事件处理的对象类
 * @Author: leo825
 * @Date: 2020-02-16 23:45
 * @Version: 1.0
 */
public class EventObject implements Serializable{

    /**
     * 对象的id
     */
    private String id;
    /**
     * 对象的名称
     */
    private String name;
    /**
     * 对象携带信息
     */
    private Map<String, Object> info;

    public EventObject(String id, String name, Map<String, Object> info) {
        this.id = id;
        this.name = name;
        this.info = info;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Map<String, Object> getInfo() {
        return info;
    }

    public void setInfo(Map<String, Object> info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "EventObject{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", info=" + info +
                '}';
    }
}

2.6.2、先定义事件的抽象实现

public abstract class AbstractEvent implements Event {

    private static final long serialVersionUID = 1L;

    /**
     * 事件处理的对象
     */
    private EventObject eventObject;

    public AbstractEvent(EventObject eventObject) {
        this.eventObject = eventObject;
    }


    @Override
    public void setEventObject(EventObject eventObject) {
        this.eventObject = eventObject;
    }

    @Override
    public EventObject getEventObject() {
        return this.eventObject;
    }
}

2.6.3、再定义各个具体的事件的实现

/**
 * @ClassName: AuditingSynEvent
 * @Description: 审核同步事件
 * @Author: leo825
 * @Date: 2020-02-17 00:06
 * @Version: 1.0
 */
public class AuditingSynEvent extends AbstractEvent{
    public AuditingSynEvent(EventObject eventObject) {
        super(eventObject);
    }
}

/**
 * @ClassName: OrderSynEvent
 * @Description: 订单同步事件
 * @Author: leo825
 * @Date: 2020-02-17 00:04
 * @Version: 1.0
 */
public class OrderSynEvent extends AbstractEvent{
    public OrderSynEvent(EventObject eventObject) {
        super(eventObject);
    }
}

/**
 * @ClassName: BillingSynEvent
 * @Description: 计费同步事件
 * @Author: leo825
 * @Date: 2020-02-17 00:06
 * @Version: 1.0
 */
public class BillingSynEvent extends AbstractEvent{
    public BillingSynEvent(EventObject eventObject) {
        super(eventObject);
    }
}

2.6.4、事件监听器定义

/**
 * @ClassName: Listener
 * @Description: 定义事件的监听器
 * @Author: leo825
 * @Date: 2020-02-17 00:18
 * @Version: 1.0
 */
public interface EventListener {
    void onEvent(Event event);
    int getSort();
}

同样事件监听器也提供一个抽象类

public abstract class AbstractEventListener implements EventListener {

    /**
     * 监听器的名称
     */
    private String name;

    /**
     * 监听器执行的顺序
     */
    private int sort;

    public String getName() {
        return name;
    }

    @Override
    public int getSort() {
        return sort;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSort(int sort) {
        this.sort = sort;
    }

    public AbstractEventListener(String name, Integer sort) {
        this.name = name;
        this.sort = sort;
    }
}

2.6.5、各个事件监听器的实现

/**
 * @ClassName: AuditingSynListener
 * @Description: 审核同步监听器
 * @Author: leo825
 * @Date: 2020-02-17 00:31
 * @Version: 1.0
 */
public class AuditingSynListener extends AbstractEventListener{
    public AuditingSynListener(String name, Integer sort) {
        super(name, sort);
    }

    @Override
    public void onEvent(Event event) {
        System.out.println("这个是审核同步事件");
        System.out.println(event);
    }
}

/**
 * @ClassName: BillingSynListener
 * @Description: 计费同步监听器
 * @Author: leo825
 * @Date: 2020-02-17 00:30
 * @Version: 1.0
 */
public class BillingSynListener extends AbstractEventListener {


    public BillingSynListener(String name, Integer sort) {
        super(name, sort);
    }

    @Override
    public void onEvent(Event event) {
        System.out.println("这个是计费同步事件");
        System.out.println(event);
    }
}

/**
 * @ClassName: OrderSynListener
 * @Description: 订单同步监听器
 * @Author: leo825
 * @Date: 2020-02-17 00:24
 * @Version: 1.0
 */
public class OrderSynListener extends AbstractEventListener {

    public OrderSynListener(String name, Integer sort) {
        super(name, sort);
    }

    @Override
    public void onEvent(Event event) {
        System.out.println("这个是订单同步事件");
        System.out.println(event);
    }
}

2.6.6、事件广播的实现

/**
 * @ClassName: EventMulticaster
 * @Description: 事件广播器
 * @Author: leo825
 * @Date: 2020-02-17 00:34
 * @Version: 1.0
 */
public class EventMulticaster {

    /**
     * 监听器列表
     */
    private static List<EventListener> listeners = new ArrayList<>();

    /**
     * 添加监听器
     *
     * @param eventListener
     * @return
     */
    public EventMulticaster addListener(AbstractEventListener eventListener) {
        listeners.add(eventListener);
        listeners = listeners.stream()
                .sorted(Comparator.comparing(EventListener::getSort))
                .collect(Collectors.toList());
        return this;
    }

    /**
     * 广播事件
     *
     * @param event
     */
    public void muticasterEvent(Event event) {
        for (EventListener eventListener : listeners) {
            eventListener.onEvent(event);
        }
    }
}

2.6.7、测试代码以及日志

    @Test
    public void muticasterTest() {
        OrderSynListener orderSynListener = new OrderSynListener("orderSyn", 2);
        BillingSynListener billingSynListener = new BillingSynListener("billingSyn", 1);
        AuditingSynListener auditingSynListener = new AuditingSynListener("auditingSyn", 3);

        EventMulticaster eventMulticaster = new EventMulticaster();
        eventMulticaster.addListener(orderSynListener).addListener(billingSynListener).addListener(auditingSynListener);


        //创建了一个订单
        EventObject eventObject = new EventObject("1","12306订单",null);

        //创建订单事件
        OrderSynEvent orderSynEvent = new OrderSynEvent(eventObject);

        //开始广播事件
        eventMulticaster.muticasterEvent(orderSynEvent);
    }

日志如下：

[2020-02-25 12:44:49.596] 订单创建完成了,触发订单同步事件OrderSynEvent
[2020-02-25 12:44:49.600] BillingSynListener监听到订单同步事件，event=com.leo.event.OrderSynEvent@1c6b6478
[2020-02-25 12:44:49.604] OrderSynListener监听到订单同步事件，event=com.leo.event.OrderSynEvent@1c6b6478
[2020-02-25 12:44:49.609] AuditingSynListener监听到订单同步事件，event=com.leo.event.OrderSynEvent@1c6b6478

2.7 策略模式

Sping在实例化对象的时候就用到了策略模式

2.8 模板方法模式

Spring中的JdbcTemplate、RestTemplate、RedisTemplate