发布订阅模式

1、发布者

package com.taoke.subscribePublish;

/**
 * 发布者
 *
 * @author taoke
 * @date 2023/4/20
 */
public interface IPublisher {

    /**
     * 发布消息
     *
     * @param dispatcher 发布订阅调度中心
     * @param message    消息
     */
    void publish(Dispatcher dispatcher, M message);

}

1.1 具体的发布者

package com.taoke.subscribePublish;

/**
 * 发布者实现类
 *
 * @author taoke
 * @date 2023/4/20
 */
public class ChildPublisher implements IPublisher {

    /**
     * 发布者名称
     */
    private final String name;

    public ChildPublisher(String name) {
        this.name = name;
    }

    /**
     * 发布消息
     *
     * @param dispatcher 发布订阅调度中心
     * @param message    消息
     */
    public void publish(Dispatcher dispatcher, M message) {
        dispatcher.publish(this.name, message);
    }
}

2、订阅者

package com.taoke.subscribePublish;

/**
 * 订阅者
 *
 * @author taoke
 * @date 2023/4/20
 */
public interface ISubscriber {

    /**
     * 订阅
     *
     * @param dispatcher 发布订阅订阅中心
     */
    void subscribe(Dispatcher dispatcher);

    /**
     * 退订
     *
     * @param dispatcher 发布订阅订阅中心
     */
    void unSubscribe(Dispatcher dispatcher);

    /**
     * 接收发布者发送的消息
     *
     * @param publisher 发布者
     * @param message   消息
     */
    void receiveMessage(String publisher, M message);

}

2.1 具体的订阅者

package com.taoke.subscribePublish;

/**
 * 订阅者实现类
 *
 * @author taoke
 * @date 2023/4/20
 */
public class ChildSubscriber implements ISubscriber {

    /**
     * 订阅者名称
     */
    public String name;

    public ChildSubscriber(String name) {
        this.name = name;
    }

    /**
     * 订阅
     *
     * @param dispatcher 发布订阅订阅中心
     */
    public void subscribe(Dispatcher dispatcher) {
        dispatcher.subscribe(this);
    }

    /**
     * 退订
     *
     * @param dispatcher 发布订阅订阅中心
     */
    public void unSubscribe(Dispatcher dispatcher) {
        dispatcher.unSubscribe(this);
    }

    /**
     * 接收发布者发送的消息
     *
     * @param publisher 发布者
     * @param message   消息
     */
    public void receiveMessage(String publisher, M message) {
        System.out.println(this.name + " 收到" + publisher + " 发来的消息: " + message.toString());
    }

}

3、消息实体类

package com.taoke.subscribePublish;

/**
 * 消息实体类
 *
 * @author taoke
 * @date 2023/4/20
 */
public class Message {

    /**
     * 发布者
     */
    private String publisher;

    /**
     * 消息
     */
    private M m;

    public Message(String publisher, M m) {
        this.publisher = publisher;
        this.m = m;
    }

    public String getPublisher() {
        return publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }
}

4、发布订阅调度中心

package com.taoke.subscribePublish;

import java.util.ArrayList;
import java.util.List;

/**
 * 发布订阅调度中心
 *
 * @author taoke
 * @date 2023/4/20
 */
public class Dispatcher {

    /**
     * 订阅者集合
     */
    private final List> subscribers = new ArrayList<>();

    public Dispatcher() {
    }

    /**
     * 发布者发布消息
     *
     * @param publisher 发布者
     * @param message   消息
     */
    public void publish(String publisher, M message) {
        for (ISubscriber subscriber : subscribers) {
            subscriber.receiveMessage(publisher, message);
        }
    }

    /**
     * 订阅
     *
     * @param subscriber 订阅者
     */
    public void subscribe(ISubscriber subscriber) {
        subscribers.add(subscriber);
    }

    /**
     * 退订
     *
     * @param subscriber 订阅者
     */
    public void unSubscribe(ISubscriber subscriber) {
        subscribers.remove(subscriber);
    }

}

5、测试类

package com.taoke.subscribePublish;

/**
 * 发布订阅模式测试类
 *
 * @author taoke
 * @date 2023/4/20
 */
public class Test {

    public static void main(String[] args) {

        //创建发布订阅调度中心
        Dispatcher dispatcher = new Dispatcher<>();
        //创建发布者和订阅者
        IPublisher publisher = new ChildPublisher<>("发布者");
        ISubscriber subscriber1 = new ChildSubscriber<>("订阅者1");
        ISubscriber subscriber2 = new ChildSubscriber<>("订阅者2");
        //订阅者1和订阅者2订阅发布者
        subscriber1.subscribe(dispatcher);
        subscriber2.subscribe(dispatcher);
        //发布者发布消息，订阅者1和订阅者2分别收到消息
        publisher.publish(dispatcher, "hello");
        publisher.publish(dispatcher, "world");

    }
}

6、测试结果