Spring的早期响应式解决方案和使用RxJava实现

1 Spring的早期响应式解决方案：发布订阅模式

Spring框架有自己的观察者模式实现，这被广泛用于跟踪应用程序的生命周期事件。从Spring 4.2开始，这种实现以及相关的API已进行了扩展，它不仅可以用于处理应用程序事件，还可以用于处理业务逻辑事件。

同时，为了实现事件分发，Spring现在为事件处理提供了@EventListener注解，为事件发布提供了ApplicationEventPublisher类。@EventListener和ApplicationEventPublisher实现了发布-订阅模式（Publish-Subscribe pattern），它可以被视为观察者模式的变体。

但是与观察者模式相反，在发布-订阅模式中，发布者和订阅者不需要彼此了解

发布-订阅模式在发布者和订阅者之间提供了额外的间接层。订阅者知道广播通知的事件通道，但通常不关心发布者的身份。此外，每个事件通道中可能同时存在几个发布者。

事件通道（event channel，也被称为消息代理或事件总线）可以额外过滤传入的消息并在订阅者之间分发它们。过滤和路由的执行可以基于消息内容或消息主题，也可以同时基于这两者。

开源Java库MBassador，可以作为Spring发布-订阅模式实现的替代方案。它的唯一目的是提供一个轻量级、高性能的事件总线，用于实现发布-订阅模式。MBassador在提供高性能的同时节省了资源
Guava库提供了EventBus库，它实现了发布-订阅模式。

1.1 spring中的发布-订阅模式演示

假设我们想要实现一个简单的Web服务，用于显示房间当前的温度。为此，我们设置一个温度传感器，它可以不时地将当前的摄氏温度通过事件发送出来。

为了使应用程序遵循响应式设计，我们不能使用旧的拉模型进行数据获取。现在有一些很好的协议可以用于从服务器到客户端的异步消息传播，即WebSocket和服务器发送事件（Server-Sent Events，SSE）。

SSE能使客户端从服务器接收自动更新，通常用于向浏览器发送消息更新或连续数据流。随着HTML5的诞生，所有现代浏览器都有一个名为EventSource的JavaScript API，请求特定URL并接收事件流的客户端将会使用它。在通信发生问题时，EventSource默认自动连接。需要强调的是，SSE是满足响应式系统中组件之间通信需求的理想选择。

将使用springboot实现,，版本是：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.2.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

1. 温度数据的封装

@Getter
public class Temperature {

    /**
     * 温度值
     */
    private final double value;

    public Temperature(double value) {
        this.value = value;
    }

}

2. 温度传感器模拟，简单模拟，每当读取到温度数据的时候，就发布事件

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

/**
 * 温度传感器
 */
@Component
public class TemperatureSensor {

    private final Random rnd = new Random();

    private final ScheduledExecutorService executor =
            Executors.newSingleThreadScheduledExecutor();

    private final ApplicationEventPublisher publisher;

    @Autowired
    public TemperatureSensor(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    @PostConstruct
    public void startProcessing() {
    	// 调度任务 
        this.executor.schedule(this::probe, 1, SECONDS);
    }

    private void probe() {
        // 使用随机数模拟传感器读取的到温度数
        double temperature = 16 + rnd.nextGaussian() * 10;
        // 发布温度事件
        publisher.publishEvent(new Temperature(temperature));
        // 发布之后，再次生成一个调度，在随机延迟（0~5）秒后调度下一次读取
        executor
                .schedule(this::probe, rnd.nextInt(5000), MILLISECONDS);
    }
}

使用ScheduledExecutorService来模拟读取温度的调度，关于这个可以参考 Executor&ExecutorService

3. 基于Spring Web MVC的异步HTTP

Servlet 3.0中引入的异步支持扩展了在非容器线程中处理HTTP请求的能力。这样的功能对于长时间运行的任务非常有用。基于这些更新，在Spring Web MVC中，我们不仅可以返回@Controller中定义的类型为T的值，还可以返回Callable 或DeferredResult 。Callable 可以在非容器线程内运行，但仍然是阻塞调用。相反，DeferredResult 能通过调用setResult(T result)方法在非容器线程上生成异步响应，以便在事件循环中使用它。

从4.2版开始，Spring Web MVC可以返回ResponseBodyEmitter，其行为类似于DeferredResult，但可以以用于发送多个对象，其中每个对象与消息转换器（由HttpMessageConverter接口定义）的实例分开编写。SseEmitter扩展了ResponseBodyEmitter，可以根据SSE的协议需求为一个传入请求发送多个传出消息。除了ResponseBodyEmitter和SseEmitter，Spring Web MVC还关注StreamingResponseBody接口。从@Controller返回时，它使我们能异步发送原始数据（有效负载字节）。StreamingResponseBody可以非常方便地流式传输大型文件而不会阻塞Servlet线程。

4. 暴露SSE端点

/**
 * @author wyaoyao
 * @date 2021/5/1 21:16
 * 该类的唯一目的是发送SSE事件
 */
@RestController
public class TemperatureController {

    private final Set<SseEmitter> clients = new CopyOnWriteArraySet<>();

    @RequestMapping(value = "/temperature-stream",method = RequestMethod.GET)
    public SseEmitter events(HttpServletRequest request){
        // 创建并返回新的SseEmitter实例，同时将该实例注册到先前的活动clients列表中
        SseEmitter sseEmitter = new SseEmitter();
        clients.add(sseEmitter);
        // SseEmitter在完成处理或已达到超时时，会将自己从clients列表中删除。
        sseEmitter.onTimeout(()->clients.remove(sseEmitter));
        sseEmitter.onCompletion(() -> clients.remove(sseEmitter));
        // 当请求-处理方法返回SseEmitter实例时，实际的请求处理过程将一直持续下去，
        // 直到SseEmitter.complete()方法被调用、发生错误或超时。
        return sseEmitter;
    }

    /**
     * 使用@EventListener注解进行修饰，以便从Spring接收事件。
     * Spring框架仅在接收到Temperature事件时才会调用handleMessage()方法
     * @Async注解将方法标记为异步执行的候选方法，
     */
    @Async
    @EventListener
    public void handleMessage(Temperature temperature){
        List<SseEmitter> deadEmitters = new ArrayList<>();
        clients.forEach(sseEmitter ->{
            try {
                // 把每个事件并行地以JSON格式异步发送给所有客户端
                sseEmitter.send(temperature, MediaType.APPLICATION_JSON);
            } catch (IOException e) {
                // 收集发生异常的sseEmitter，后面就从活动clients列表中删除
                deadEmitters.add(sseEmitter);
            }
        });
        // 发生异常的sseEmitter，就从活动clients列表中删除
        clients.removeAll(deadEmitters);
    }

}

5. 主启动

@SpringBootApplication
// 启用异步执行功能
@EnableAsync
public class Application implements AsyncConfigurer {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(5);
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler(){
        return new SimpleAsyncUncaughtExceptionHandler();
    }

}

6. 提供一个页面

<body>
    <ul id="events"></ul>

    <script type="application/javascript">
        function add(message){
            const el = document.createElement("li");
            el.innerHTML = message;
            document.getElementById("events").appendChild(el);

        }
        // 访问/temperature-stream
        var eventSource = new EventSource("/temperature-stream")
        eventSource.onmessage = e => {
            const t = JSON.parse(e.data);
            const fixed = Number(t.value).toFixed(2);
            add('Temperature: ' + fixed + ' C');
        }
        eventSource.onopen = ev => add('Connection opened');
        eventSource.onerror = e => add('Connection closed');

    </script>

</body>

在重新构建和完成应用程序的启动之后，我们应该能够在浏览器中打开以下地址访问网页：http://localhost:8080
几秒后，我们会看到以下输出：

我们可以看到，该网页响应式地接收事件，同时节省客户端资源和服务器资源。它还支持在网络发生问题或超时的情况下自动重新连接。

回顾一下：

1. 浏览器访问localhost:8080的时候，通过js访问了服务端/temperature-stream

2. 后端便创建本次连接的对象SseEmitter，并保存下来

3. 并且定义了当前SseEmitter注册了两个回调onTimeout和onCompletion

4. 立即返回当前SseEmitter

5. 一旦订阅到温度变化事件，就会通过SseEmitter发送给客户端

6. 解决方案的问题
   目前的解决方案存在一些问题。
   首先，我们使用了Spring提供的发布-订阅基础结构。在Spring框架中，这种机制最初是为处理应用程序生命周期事件而引入的，它并不适用于高负载、高性能的场景。

这种方法的一个重要缺点在于，我们使用内部Spring机制来定义和实现业务逻辑。这导致框架中的一些微小变化可能破坏应用程序。同时，如果不运行应用程序上下文，就很难对我们的业务规则进行单元测试。

需要分配线程池用于异步广播温度事件。如果使用真正的异步和响应式方法（框架），我们就不必这样做。

我们的温度传感器只生成一个事件流，而不考虑有多少客户端在监听。但是，当没有客户端在监听时，温度传感器也会创建事件流。这可能导致资源浪费，因为创建动作需要消耗较大资源。

例如，我们的组件可能与真实实硬件通信，这就会缩短硬件寿命。

为了解决以上所有问题以及其他问题，我们需要一个专门为此目的而设计的响应式库。幸好，我们有一些这样的响应式库。我们将关注RxJava，它是第一个被广泛应用的响应式库，改变了我们使用Java构建响应式应用程序的方式。

2 使用RxJava实现

1. 模拟温度传感器，模拟产生数据流

@Component
@Slf4j
public class RxTemperatureSensor {

    private static final Random rnd = new Random();


    // 模拟数据产生
    Observable<Temperature> dataStream = Observable.range(0, Integer.MAX_VALUE)
            .concatMap(tick -> Observable.just(tick)
                    .delay(rnd.nextInt(5000), TimeUnit.MILLISECONDS))
            .map(tick -> this.probe())
            .publish()
            .refCount();

    private Temperature probe() {
        return new Temperature(16 + rnd.nextGaussian() * 10);
    }

    public Observable<Temperature> temperatureStream() {
        return dataStream;
    }
}

dataStream生成无限的数字流。range()方法会生成一个从0开始的具有Integer.MAX_VALUE个元素的整数序列。我们使用concatMap(tick - > …)方法，针对这些值中的每一个进行转换。concatMap()方法接收一个函数f，该函数会将tick项转换为可观察的元素流，我们将f函数应用于传入流的每个元素，并逐个连接生成的流。

为了模拟随机延迟，我们应用delay操作符

通过map(tickValue -> this.probe())转换操作来探测传感器并获取温度值，在这种情况下，我们忽略tickValue，因为它只需要生成一个单元素流。因此，在应用concatMap(tick -> …)方法之后，我们有了一个流，它不但返回传感器值，而且其所发送的元素之间的随机间隔最多为5秒。

实际上，我们可以在不应用操作符(9)和(10)的情况下返回流，但在这种情况下，每个订阅者（SSE客户端）都将触发流的新订阅和新的传感器读数序列。这意味着订阅者之间不会共享传感器读数，而这可能导致硬件过载和降级。为了防止这种情况，我们将使用publish()(9)操作符，该操作符可以将源流中的事件广播到所有目标流。publish()操作符返回一种名为ConnectableObservable的特殊Observable。

ConnectableObservable提供refCount()操作符，该操作符仅在存在至少一个传出订阅时才创建对传入共享流的订阅。与发布者-订阅者的实现相比，这个实现不会在没有人监听时去探测传感器。

2. 自定义SseEmitter

public class RxSseEmitter extends SseEmitter {

    private final Subscriber<Temperature> subscriber;

    public RxSseEmitter() {
        // 超时时间
        super(30 * 60 * 1000L);
        // 定义订阅逻辑
        this.subscriber = new Subscriber<Temperature>() {
            @Override
            public void onCompleted() { }

            @Override
            public void onError(Throwable e) { }

            @Override
            public void onNext(Temperature temperature) {
                try {
                    send(temperature);                          // (4)
                } catch (IOException e) {
                    unsubscribe();                                                // (5)
                }
            }
        };
    }

    public Subscriber<Temperature> getSubscriber() {
        return this.subscriber;
    }

    @Override
    public synchronized void onTimeout(Runnable callback) {
        super.onTimeout(callback);
        this.subscriber.unsubscribe();
    }

    @Override
    public synchronized void onError(Consumer<Throwable> callback) {
        super.onError(callback);
        this.subscriber.unsubscribe();
    }

    @Override
    public synchronized void onCompletion(Runnable callback) {
        super.onCompletion(callback);
        this.subscriber.unsubscribe();
    }
}

3. 暴露SSE端点，修改之前的TemperatureController

@RestController
public class TemperatureController {

    private final Set<SseEmitter> clients = new CopyOnWriteArraySet<>();

    private final RxTemperatureSensor rxTemperatureSensor;

    public TemperatureController(RxTemperatureSensor rxTemperatureSensor) {
        this.rxTemperatureSensor = rxTemperatureSensor;
    }

    @RequestMapping(value = "/temperature-stream",method = RequestMethod.GET)
    public SseEmitter events(HttpServletRequest request){
  
        RxSseEmitter emitter = new RxSseEmitter();

        rxTemperatureSensor.temperatureStream()
                .subscribe(emitter.getSubscriber());
        return emitter;

    }
}

再次启动访问，结果如下：