Bootstrap

java设计模式之监听者模式

有这么一个需求,客户注册的时候,产品经理要求给客户发送短信,发送优惠券,还有就是发送积分。根据xp极限编程原则,只管今天不管明天,伪代码原则上

//1,注册
register();
//2,发送优惠券
sendCoupon();
//3,发送短信
sendSMS();
//4,发送积分
sendIntegral();

看得出来,这个代码逻辑一点问题都没有,但是
产品经理说:喂,最近公司效益不好,积分和优惠券就不要发送了。
于是,你又可能去注释掉发送优惠券和积分的代码,这没什么问题,然后组织测试人员在测试一波,简单就可以上线。
于是又过了几天。
产品经理又说:喂!最近效益不好,需要刺激用户消费,注册的时候继续发送优惠券和积分。
你说: 好的!
于是你又把注释的代码放开!!感觉so easy!
于是又过了几天。
产品说:喂,注册的功能很慢,而且经常会失败,你知道这会让很多客户流失,给公司造成很大损失。
然后你带着问题,去查询日志,最后发现是调用第三方短信服务特别慢,有时候还有失败,然后你就理直气壮的耍锅。
你说:经理,这个跟我写的代码没有关系,是因为第三方短信平台不稳定,日志都复制给你了,您瞧瞧!!
产品经理撇了你一眼。
说:短信发不发的无所谓,核心注册一定要成功!!
这个时候,你应该感觉到,这个注册逻辑变来变去,而且产品的需求也是合情合理,所以本着事不过三,三则重构的原则。前面简单的代码堆砌方式已经不能满足我们的需求变化了,所以我们要想怎么样优化自己的代码。


我们的代码逻辑没什么问题,矛盾在于,我们的主干逻辑和一些次要逻辑耦合在一起。使得主干逻辑一直没有变,次要的功能确实频繁的变化,这个时候,我们学习的监听者模式就派上用场了,然后主干逻辑和次要功能解耦。
我们这可以这样做,有四个人:注册器,工具人A,工具人B,工具人C,注册器负责主要逻辑,工具人A负责发送优惠券,工具人B负责发送积分,工具人C负责发送短信,当我的注册器有用户注册的时候,就广播给其他的工具人,让他们各司其职,该干嘛就干嘛。这个时候,我们发现,我们的注册逻辑主要和广播器耦合,负责帮我们广播信息就可以,至于具体工具人做什么事情,他是不知道的。而我们频繁去修改次要功能的时候,也不需要去修改我们的主干逻辑部分的代码。

事件模式中的几个概念

事件源:事件的触发者,也就是上面的注册器。
事件:描述一个动作,这里就是我们可以理解为注册这个动作。
事件监听器:监听到事件后,做的一些处理,就是上面的工具人。
事件广播器:负责广播信息给监听者。

下面我们使用监听者模式实现用户注册的业务

我们先来定义和事件相关的几个类
事件对象

表示所有事件的父类,内部有个source字段,表示事件源;我们自定义的事件需要继承这个类

package com.shiguiwu.springmybatis.spring.event.pattern;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @description: 事件对象
 * @author: stone
 * @date: Created by 2021/4/8 10:21
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event.pattern
 */
@Data
@AllArgsConstructor
public abstract class AbstractEvent {

    //事件源

    //事件源:事件的触发者,比如上面的注册器就是事件源。
    private Object source;
}
事件监听器

我们使用一个接口来表示事件监听器,是个泛型接口,后面的类型 E 表示当前监听器需要监听的事件类型,此接口中只有一个方法,用来实现处理事件的业务;其定义的监听器需要实现这个接口。

/**
 * @description: 事件监听
 *
 * :监听到事件发生的时候,做一些处理,比如上面的:路人A、路人B
 * @author: stone
 * @date: Created by 2021/4/8 10:29
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event.pattern
 */
public interface EventListener<E extends AbstractEvent> {

    /**
     * 此方法负责处理事件
     * @param e 事件对象
     */
    public void onEvent(E e);
}
事件广播器
  • 负责事件监听器的管理(注册监听器&移除监听器,将事件和监听器关联起来)
  • 负责事件的广播(将事件广播给所有的监听器,对该事件感兴趣的监听器会处理该事件)
/**
 * @description: 事件广播
 * @author: stone
 * @date: Created by 2021/4/8 10:36
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event.pattern
 *
    **事件广播器:
    **1.负责事件监听器的管理(注册监听器&移除监听器,将事件和监听器关联起来)
    **2.负责事件的广播(将事件广播给所有的监听器,对该事件感兴趣的监听器会处理该事件)
    **/
public interface EventMulticaster {

    /**
     * 广播事件所有的监听器,对该事件感兴趣的监听会处理该事件
     * @param event
     */
    public void multicastEvent(AbstractEvent event);


    /**
     * 添加一个事件监听器
     * @param eventListener
     */
    public void addEventListener(EventListener<?> eventListener);

    /**
     * 将一个监听器移除
     * @param eventListener
     */
    public void removeEventListener(EventListener<?> eventListener);
广播器的简单实现
/**
 * @description: 事件广播
 * @author: stone
 * @date: Created by 2021/4/8 10:36
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event.pattern
 *
    **事件广播器:
    **1.负责事件监听器的管理(注册监听器&移除监听器,将事件和监听器关联起来)
    **2.负责事件的广播(将事件广播给所有的监听器,对该事件感兴趣的监听器会处理该事件)
    **/
public interface EventMulticaster {

    /**
     * 广播事件所有的监听器,对该事件感兴趣的监听会处理该事件
     * @param event
     */
    public void multicastEvent(AbstractEvent event);


    /**
     * 添加一个事件监听器
     * @param eventListener
     */
    public void addEventListener(EventListener<?> eventListener);

    /**
     * 将一个监听器移除
     * @param eventListener
     */
    public void removeEventListener(EventListener<?> eventListener);
广播器的简单实现
/**
 * @description: 简单事件广播
 * @author: stone
 * @date: Created by 2021/4/8 11:04
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event
 */
public class SimpleEventMulticaster implements EventMulticaster {

    private Map<Class<?>, List<EventListener>> eventObjectEventListenerMap = new ConcurrentHashMap<>();


    @Override
    public void multicastEvent(AbstractEvent event) {
        List<EventListener> eventListeners = eventObjectEventListenerMap.get(event.getClass());
        if (eventListeners != null) {
            eventListeners.parallelStream().forEach(e -> e.onEvent(event));
        }

    }

    @Override
    public void addEventListener(EventListener<?> eventListener) {
        Class<?> eventType = this.getEventType(eventListener);
        List<EventListener> listeners = this.eventObjectEventListenerMap.computeIfAbsent(eventType, e -> new ArrayList<>());
        listeners.add(eventListener);
    }

    @Override
    public void removeEventListener(EventListener<?> eventListener) {
        Class<?> eventType = this.getEventType(eventListener);
        List<EventListener> eventListeners = this.eventObjectEventListenerMap.get(eventType);
        if (eventListeners != null) {
            eventListeners.remove(eventListener);
        }
    }

    /**
     * 获取事件的类型,这里的代码可能不是很常见,其实就是获取泛型类型而已
     * @param eventListener
     * @return
     */
    protected Class<?> getEventType(EventListener<? extends AbstractEvent> eventListener) {
        ParameterizedType parameterizedType = (ParameterizedType) eventListener.getClass().getGenericInterfaces()[0];
        Type actualTypeArgument = parameterizedType.getActualTypeArguments()[0];
        return (Class<?>) actualTypeArgument;
    }
}

上面3个类支撑了整个时间模型,下面我们使用上面三个类来实现注册的功能,目标是:高内聚低耦合,让注册逻辑方便扩展。

自定义用户注册成功事件类

继承了 AbstractEvent 类

/**
 * @description: 用户注册事件
 * @author: stone
 * @date: Created by 2021/4/8 11:56
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event
 */
@Getter
public class RegisterSuccessEvent  extends AbstractEvent {

    private String username;

    public RegisterSuccessEvent(Object source, String username) {
        super(source);
        this.username = username;
    }
}
用户注册服务

负责实现用户注册逻辑


/**
 * @description: 用户注册服务
 * @author: stone
 * @date: Created by 2021/4/8 14:14
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event
 */
@Data
public class RegisterService {

    private EventMulticaster eventMulticaster;

    public void register(String username) {
        //用户注册,将数据写人到数据库中
        System.out.println("用户注册成功。。。。" + username);

        //事件广播
        //使用事件发布者eventPublisher发布用户注册成功的消息:
        this.eventMulticaster.multicastEvent(new RegisterSuccessEvent(this, username));
    }
}
自定义监听者

发送优惠券

/**
 * @description: 注册成功后发优惠券
 * @author: stone
 * @date: Created by 2021/4/8 15:28
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event
 */
public class GetCouponRegisterSuccessListener implements EventListener<RegisterSuccessEvent> {

    @Override
    public void onEvent(RegisterSuccessEvent event) {
        System.out.println(event.getUsername() + "注册成功,赠送优惠券。。。。。");

    }
}

发短信

package com.shiguiwu.springmybatis.spring.event;

import com.shiguiwu.springmybatis.spring.event.pattern.EventListener;

/**
 * @description: 注册成功后发短信
 * @author: stone
 * @date: Created by 2021/4/8 15:28
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event
 */
public class SendSMSUserRegisterSuccessListener implements EventListener<RegisterSuccessEvent> {

    @Override
    public void onEvent(RegisterSuccessEvent event) {
        System.out.println(event.getUsername() + "注册成功,发送短信。。。。。");

    }
}
``

#### 下面我们使用spring来将上面的对象组装起来
```java
package com.shiguiwu.springmybatis.spring.event;

import com.baomidou.mybatisplus.extension.api.R;
import com.shiguiwu.springmybatis.spring.event.pattern.EventListener;
import com.shiguiwu.springmybatis.spring.event.pattern.EventMulticaster;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.List;

/**
 * @description: 配置类
 * @author: stone
 * @date: Created by 2021/4/8 14:30
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event
 */
@Configuration("eventConfig1")
public class EventConfig {

    /**
     * 注册一个事件发布者bean
     * @param eventListeners
     * @return
     */
    @Bean
    @Autowired(required = false)
    public EventMulticaster eventMulticaster(List<EventListener> eventListeners) {
        SimpleEventMulticaster simpleEventMulticaster = new SimpleEventMulticaster();
        if (eventListeners != null) {
            eventListeners.parallelStream().forEach(simpleEventMulticaster::addEventListener);
        }
        return simpleEventMulticaster;
    }

    /**
     * 用户注册服务
     * @param eventMulticaster
     * @return
     */
    @Bean
    public RegisterService registerService(EventMulticaster eventMulticaster) {
        RegisterService registerService = new RegisterService();
        registerService.setEventMulticaster(eventMulticaster);
        return registerService;
    }

    @Bean
    public EventListener<RegisterSuccessEvent> successEventEventListener() {
        return new SendSMSUserRegisterSuccessListener();
    }

    @Bean
    public EventListener<RegisterSuccessEvent> eventEventListener() {
        return new GetCouponRegisterSuccessListener();
    }
}

测试代码如下

package com.shiguiwu.springmybatis.spring.event;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @description: spring事件模式
 *
 * 事件源:事件的触发者,比如上面的注册器就是事件源。
 * 事件:描述发生了什么事情的对象,比如上面的:xxx注册成功的事件
 * 事件监听器:监听到事件发生的时候,做一些处理,比如上面的:路人A、路人B
 * @author: stone
 * @date: Created by 2021/4/8 10:16
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.event
 */
public class EventTests {

    public static void main(String[] args) {
        //模拟用户注册
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(EventConfig.class);
        RegisterService bean = context.getBean(RegisterService.class);
        //用户注册
        bean.register("administrator");

    }
}

小结
上面将注册的主要逻辑(用户信息落库)和次要的业务逻辑(发送短信)通过事件的方式解耦了。次要的业务做成了可插拔的方式,比如不想发送短信了,只需要将邮件监听器上面的 @Component 注释就可以了,非常方便扩展。上面用到的和事件相关的几个类,都是我们自己实现的,其实这些功能在spring中已经帮我们实现好了,用起来更容易一些,下面带大家来体验一下。

;