springmvc的dispatchservlet使用了什么模式 springmvc用到了哪些设计模式

转载

mob64ca1405d568 2024-03-26 08:49:22

文章标签 spring 学习代理模式监听器 ide 文章分类 架构后端开发

文章目录

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

2.1 简单工厂模式
2.2 工厂方法模式
2.3 适配器模式
2.4 装饰器模式（包装器模式）
2.5 代理模式
2.6 观察者模式

2.6.1、先定义一个Event
2.6.2、先定义事件的抽象实现
2.6.3、再定义各个具体的事件的实现
2.6.4、事件监听器定义
2.6.5、各个事件监听器的实现
2.6.6、事件广播的实现
2.6.7、测试代码以及日志

2.7 策略模式
2.8 模板方法模式

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