关于设计模式:浅析观察者模式在Java中的应用

103次阅读

共计 9301 个字符，预计需要花费 24 分钟才能阅读完成。

观察者模式（Observer Design Pattern）, 也叫做公布订阅模式（Publish-Subscribe Design Pattern）、模型 - 视图（Model-View）模式、源 - 监听器（Source-Listener）模式、隶属者（Dependents）模式

观察者模式利用最广的场景就是音讯公布订阅，比方当零碎中实现一个业务事件，须要告诉给不同的用户平台，这个时候就会有多种告诉形式，如：

那么就须要将音讯公布对象这一个状态的扭转，告诉给另外多个平台的对象，像这种状况就适宜观察者模式。上面就具体的介绍一下观察者模式

一、观察者模式的介绍

后面说到，观察者是一种行为设计模式，容许一个对象将其状态的扭转告诉其余对象。实际上次要的局部就是观察者和被观察者，比方前言提到的音讯公布，就属于被观察者，而各种不同的平台音讯揭示，则是一系列的观察者。那么观察者如何获取被观察者的状态变动呢？在观察者模式中是这样设计的：

1.1 观察者模式的构造

在被观察者这一块，通过在被观察者中治理观察者，如add（） 减少观察者，remove() 移除观察者和notifyObserver() 告诉 / 发送音讯给观察者等等办法，来达到告诉观察者，治理观察者数量的作用。在观察者这个角度，须要有response() 接管被观察者告诉的办法，来实现整个观察者模式的闭环。用 UML 图来展现则如下所示：

观察者模式构造中次要包含被观察者（Object）和观察者（Observer）两个构造：

  • Subject：主题抽象类，提供一系列观察者对象，以及对这些对象的减少、删除和告诉的办法
  • ConcreteSubject：主题具体实现类，实现形象主题中的告诉办法，告诉所有注册过的观察者对象
  • Observer：观察者抽象类，蕴含一个告诉响应形象办法
  • ConcreteObserver1、ConcreteObserver2：观察者实现类，实现形象观察者中的办法，以便在失去指标的更改告诉时更新本身的状态
  • Client：客户端，对主题及观察者进行调用

从下面的 UML 图咱们会晓得，通过形象观察者和被观察者，而后别离实现不同的观察者和被观察者，来达到将多个对象的不同状态传递给多个对象的作用。

1.2 观察者模式的实现

依据下面的类图，咱们能够实现对应的代码。

首先定义一个形象指标类Subject，其中包含减少、登记和告诉观察者办法

public abstract class Subject {protected List<Observer> observerList = new ArrayList<Observer>();

    /**
     * 减少观察者
     * @param observer 观察者
     */
    public void add(Observer observer) {observerList.add(observer);
    }

    /**
     * 登记观察者，从观察者汇合中删除一个观察者
     * @param observer 观察者
     */
    public void remove(Observer observer) {observerList.remove(observer);
    }

    /** 告诉观察者 */
    public abstract void notifyObserver();}

对应具体的指标类ConcreteSubject

public class ConcreteSubject extends Subject{

    @Override
    public void notifyObserver() {System.out.println("遍历观察者：");
        for (Observer observer : observerList) {observer.response();
        }
    }
}

此外须要定义形象观察者 Observer，它个别定义为一个接口，申明一个response() 办法，为不同观察者的响应行为定义雷同的接口：

public interface Observer {
    /** 申明响应办法 */
    void response();}

具体的观察者实现：

public class ConcreteObserver1 implements Observer{

    @Override
    public void response() {System.out.println("我是具体观察者 ConcreteObserver1");
    }
}

public class ConcreteObserver2 implements Observer{

    @Override
    public void response() {System.out.println("我是具体观察者 ConcreteObserver2");
    }
}

最初是客户端测试：

public class Client {public static void main(String[] args) {Subject concreteSubject = new ConcreteSubject();
        // 具体观察者
        Observer concreteObserver1 = new ConcreteObserver1();
        Observer concreteObserver2 = new ConcreteObserver2();
        concreteSubject.add(concreteObserver1);
        concreteSubject.add(concreteObserver2);
        
        concreteSubject.notifyObserver();}
}

测试后果：

遍历观察者：我是具体观察者 ConcreteObserver1
我是具体观察者 ConcreteObserver2

1.3 观察者模式和订阅发布者模式的区别

在平时的开发中，咱们也会接触到订阅发布者模式（Pub-Sub Pattern），后面咱们也说到它是观察者模式另外一种叫法，然而它们两者之间有什么不同呢？先来看看两个模式的实现构造：

在理论业务中，公布订阅者模式就是消息中间件的实现，两者的区别在于：观察者模式中，被观察者和观察者两者间接相干依赖，而在公布订阅者模式中，因为有调度核心的存在，被观察者和观察者两者不相互依赖，因而对于公布订阅者模式，实现了被观察者和观察者的解耦，更利于各个组件的独立扩大。

在具体调度核心中，能够通过不同的消息中间件来实现，比方 Java 中的 RabbitMQ, Kafka 等等

二、观察者模式的利用场景

在以下状况就能够思考应用观察者模式：

  1. 一个对象的扭转会导致一个或多个对象产生扭转，而并不知道具体有多少对象将会产生扭转，也不晓得这些对象是谁
  2. 当一个形象模型有两个方面，其中的一个方面依赖于另一个方面时，可将这两者封装在独立的对象中以使他们能够各自独立地扭转和复用
  3. 须要在零碎中创立一个触发链，使得事件领有跨域告诉（逾越两种观察者的类型）

2.1 观察者模式在 java.util 包中的利用

观察者模式在 JDK 中就有典型利用，比方 java.util.Observable 和java.util.Observer类。构造如下图所示：

咱们能够通过实现具体的 ConcreteObserver 和具体的 ConcreteObservable 实现观察者模式流程

2.2 观察者模式在 MVC 中的利用

MVC(Modew-View-Controller)架构中也利用了观察者模式，其中模型（Model）能够对应观察者模式中的察看指标，而视图（View）对应于观察者，控制器（Controller）就是中介者模式的利用：

三、观察者模式实战

3.1 在本案例中模仿北京小客车指标摇号事件的音讯告诉场景（来源于《重学 Java 设计模式》）

对于告诉事件，能够将其分成三个局部：事件监听 、 事件处理 和具体的业务流程，如下图所示：

对于和外围流程和非核心流程的构造，非核心流程能够是异步的，在 MQ 以及定时工作的解决下，可能最终保障一致性。

3.1.1 具体代码实现

  1. 事件监听接口及具体实现

这个局部就相当于观察者（Observer）的角色，须要被观察者将信息发送给这些不同的观察者

在接口中定义根本事件类办法doEvent()，相当于 UML 图中的response() 办法

public interface EventListener {void doEvent(LotteryResult result);

}

监听事件的具体实现MessageEventListener（短消息事件）和MQEventListener（MQ 发送事件）

public class MessageEventListener implements EventListener{private Logger logger = LoggerFactory.getLogger(MessageEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {logger.info("给用户 {} 发送短信告诉(短信)：{}", result.getuId(), result.getMsg());
    }
}

public class MQEventListener implements EventListener{private Logger logger = LoggerFactory.getLogger(MQEventListener.class);

    @Override
    public void doEvent(LotteryResult result) {logger.info("记录用户 {} 摇号后果(MQ)：{}", result.getuId(), result.getMsg());
    }
}
  1. 事件处理类

该局部就相当于 Object 局部，也就是被观察者

对于不同的事件类型（MQ 和 Message）进行枚举解决，并提供三个办法：subscribe()、unsubscribe()和 notify() 用于对监听事件的注册和应用：

public class EventManager {Map<Enum<EventType>, List<EventListener>> listeners = new HashMap<>();

    public EventManager(Enum<EventType>... operations) {for (Enum<EventType> operation : operations) {listeners.put(operation, new ArrayList<>());
        }
    }

    public enum EventType {
        MQ,
        Message
    }

    /**
     * 订阅
     * @param eventType 事件类型
     * @param listener  监听
     */
    public void subscribe(Enum<EventType> eventType, EventListener listener) {List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.add(listener);
    }

    /**
     * 勾销订阅
     * @param eventType 事件类型
     * @param listener 监听
     */
    public void unsubscribe(Enum<EventType> eventType, EventListener listener) {List<EventListener> eventListeners = listeners.get(eventType);
        eventListeners.remove(listener);
    }

    /**
     * 告诉
     * @param eventType 事件类型
     * @param result    后果
     */
    public void notify(Enum<EventType> eventType, LotteryResult result) {List<EventListener> eventListeners = listeners.get(eventType);
        for (EventListener eventListener : eventListeners) {eventListener.doEvent(result);
        }
    }
}
  1. 业务抽象类接口及其实现

这一部分不属于观察者模式中的局部，是属于具体业务中的代码，通过应用抽象类的形式实现办法能够在办法中扩大额定的调用，并提供形象办法doDraw（），让继承者去实现具体逻辑

public abstract class LotteryService {

    private EventManager eventManager;

    public LotteryService() {eventManager = new EventManager(EventManager.EventType.MQ, EventManager.EventType.Message);
        eventManager.subscribe(EventManager.EventType.MQ, new MQEventListener());
        eventManager.subscribe(EventManager.EventType.Message, new MessageEventListener());
    }

    public LotteryResult draw(String uId) {LotteryResult lotteryResult = doDraw(uId);
        eventManager.notify(EventManager.EventType.MQ, lotteryResult);
        eventManager.notify(EventManager.EventType.Message, lotteryResult);
        return lotteryResult;
    }

    protected abstract LotteryResult doDraw(String uId);
}

public class LotteryServiceImpl extends LotteryService{private MinibusTargetService minibusTargetService = new MinibusTargetService();

    @Override
    protected LotteryResult doDraw(String uId) {
        // 摇号测试
        String lottery = minibusTargetService.lottery(uId);
        return new LotteryResult(uId, lottery, new Date());
    }
}
  1. 其余的类

摇号服务接口：

/**
 * 小客车指标调控服务
 */
public class MinibusTargetService {

    /**
     * 模仿摇号，但不是摇号算法
     *
     * @param uId 用户编号
     * @return 后果
     */
    public String lottery(String uId) {return Math.abs(uId.hashCode()) % 2 == 0 ? "祝贺你，编码".concat(uId).concat("在本次摇号中签") : "很遗憾，编码".concat(uId).concat("在本次摇号未中签或摇号资格已过期");
    }

}

事件信息返回类：用于返回信息，在理论业务中这一部分能够进行对应的取舍

public class LotteryResult {

    private String uId;
    private String msg;
    private Date dateTime;

    //get set constructor... 
}
  1. 测试类
public class ApiTest {private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    @Test
    public void test() {LotteryServiceImpl lotteryService = new LotteryServiceImpl();
        LotteryResult result = lotteryService.draw("1234567");
        logger.info("摇号后果：{}", JSON.toJSONString(result));
    }
}

测试后果：

11:43:09.284 [main] INFO  c.e.d.event.listener.MQEventListener - 记录用户 1234567 摇号后果(MQ)：祝贺你，编码 1234567 在本次摇号中签
11:43:09.288 [main] INFO  c.e.d.e.l.MessageEventListener - 给用户 1234567 发送短信告诉(短信)：祝贺你，编码 1234567 在本次摇号中签
11:43:09.431 [main] INFO  ApiTest - 摇号后果：{"dateTime":1649475789279,"msg":"祝贺你，编码 1234567 在本次摇号中签","uId":"1234567"}

3.2 监听系统工作流实现音讯，别离发送给不同的平台，比方微信，钉钉等

3.2.1 具体代码实现

  1. 音讯事件监听

该类监听系统中的流程信息，通过这个 processor 来治理第三方平台，并选择性推送。继承 ThirdMessageListener，接管零碎传递过去的流程信息 userMessage。

@ThirdMessageListenerAnnotation
public class ThirdMessageProcessor implements ThirdMessageListener {

    @Autowired
    private WeChatMessageSender weChatMessageSender;

    @Value("${sys.ThirdPlatform.weChat}")
    private boolean weChatSwitch;

    @Value("${sys.ThirdPlatform.DingDing}")
    private boolean dingDingSwitch;

    @Override
    public void onMessage(FlowUserMessage userMessage) {
        // 若在零碎配置文件中敞开该三方平台, 则对该平台不发送音讯
        if (weChatSwitch || dingDingSwitch) {
            // 集成各种第三方平台
            MessageSenderManager messageSenderManager = new MessageSenderManager(MessageSenderManager.MessagePlatform.weChat);
            // 将微信平台集成在音讯发送管理器中
            messageSenderManager.subscribe(MessageSenderManager.MessagePlatform.weChat, beijingOfficeMessageSender);
            // 向微信平台发送音讯
            messageSenderManager.notify(MessageSenderManager.MessagePlatform.weChat, userMessage);
        }
    }
}

  1. 音讯发送管理器

    该局部是 MessageSenderManager，相当于观察者模式中的被观察者，对不同的观察者进行治理和音讯发送：

public class MessageSenderManager {Map<Enum<MessagePlatform>, List<MessageSender>> senders = new HashMap<>();

    public MessageSenderManager(Enum<MessagePlatform>... operations) {for (Enum<MessagePlatform> operation : operations) {senders.put(operation, new ArrayList<>());
        }
    }

    /**
     * 配置不同平台类型
     */
    public enum MessagePlatform {
        /**
         * 微信平台
         */
        Wechat,
        DingDing
    }

    /**
     * 订阅对应平台的监听器
     * @param platformType 平台类型
     * @param sender 监听器
     */
    public void subscribe(Enum<MessagePlatform> platformType, MessageSender sender) {List<MessageSender> messageSenders = senders.get(platformType);
        messageSenders.add(sender);
    }

    /**
     * 勾销对应平台的监听器
     * @param platformType 平台类型
     * @param sender 监听器
     */
    public void unsubscribe(Enum<MessagePlatform> platformType, MessageSender sender) {List<MessageSender> messageSenders = senders.get(platformType);
        messageSenders.remove(sender);
    }

    /**
     * 告诉音讯
     * @param platformType 平台类型
     * @param userMessage 监听器
     */
    public void notify(Enum<MessagePlatform> platformType, FlowUserMessage userMessage) {List<MessageSender> messageSenders = senders.get(platformType);
        for (MessageSender messageSender : messageSenders) {messageSender.sendMessage(userMessage);
        }
    }

}
  1. 具体平台音讯发送

该局部是具体的平台音讯发送过程，也就是观察者，当观察者订阅后，每次被察看状态变动后，都会将该状态发送给观察者。

public interface MessageSender {

    /**
     * 发送音讯
     * @param userMessage 流程音讯
     */
    void sendMessage(FlowUserMessage userMessage);

    /**
     * 重发消息
     * @param userMessage 流程音讯
     */
    void resendMessage(FlowUserMessage userMessage);
}

@Component
public class WeixinMessageSender implements MessageSender{


    @Override
    public void sendMessage(FlowUserMessage userMessage) {...}

    @Override
    public void resendMessage(FlowUserMessage userMessage) {...}

}

四、参考资料

《重学 Java 设计模式》

《设计模式》

http://c.biancheng.net/view/1390.html

正文完
设计模式
发表至： 设计模式
2023-09-07
 0
关于设计模式:一文彻底搞懂观察者模式Observer-Pattern
关于设计模式:设计模式建造者模式
关于设计模式:设计模式单例模式
关于设计模式:设计模式7-探索一下桥接模式