Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/jmnarloch/rxjava-spring-boot-starter
RxJava Spring MVC integration
https://github.com/jmnarloch/rxjava-spring-boot-starter
java reactive rxjava rxjava-spring-mvc spring spring-boot
Last synced: 7 days ago
JSON representation
RxJava Spring MVC integration
- Host: GitHub
- URL: https://github.com/jmnarloch/rxjava-spring-boot-starter
- Owner: jmnarloch
- License: apache-2.0
- Created: 2016-01-21T11:54:34.000Z (almost 9 years ago)
- Default Branch: master
- Last Pushed: 2021-03-12T04:26:16.000Z (almost 4 years ago)
- Last Synced: 2024-12-26T12:08:18.001Z (14 days ago)
- Topics: java, reactive, rxjava, rxjava-spring-mvc, spring, spring-boot
- Language: Java
- Size: 127 KB
- Stars: 182
- Watchers: 10
- Forks: 46
- Open Issues: 3
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Spring MVC RxJava handlers
> A Spring Boot starter for RxJava integration
[](https://travis-ci.org/jmnarloch/rxjava-spring-boot-starter)
[](https://coveralls.io/github/jmnarloch/rxjava-spring-boot-starter?branch=master)
## Setup
Add the Spring Boot starter to your project:
```xml
io.jmnarloch
rxjava-spring-boot-starter
2.0.0
```
Note:
If you need RxJava 1.4.x support use version 1.0.0. For RxJava2 use 2.x.
## Usage
### Basic
Registers Spring's MVC return value handlers for `rx.Observable` and `rx.Single` types. You don't need to any longer use
blocking operations or assign the values to DeferredResult or ListenableFuture instead you can declare that your REST
endpoint returns Observable.
Example:
```
@RestController
public static class InvoiceResource {
@RequestMapping(method = RequestMethod.GET, value = "/invoices", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
public Observable getInvoices() {
return Observable.just(
new Invoice("Acme", new Date()),
new Invoice("Oceanic", new Date())
);
}
}
```
The `Observable` will wrap any produced results into a list and make it process through Spring's message converters.
In case if you need to return exactly one result you can use `rx.Single` instead. You can think of `rx.Single`
as counterpart of Spring's `DeferredResult` or `ListenableFuture`. Also with `rx.Single`, and unlike with `rx.Observable`
it is possible to return `ResponseEntity` in order to have the control of the HTTP headers or the status code of the
response.
Note: The `HandlerReturnValueHandler` for Observable uses 'toList' operator to aggregate the results, which
is not workable with really long infinitive running Observables, from which is not possible to unsubscribe.
In some scenarios when you want to have more control over the async processing you can use either `ObservableDeferredResult`
or `SingleDeferredResult`, those are the specialized implementation of `DeferredResult` allowing for instance of setting
the processing timeout per response.
### Server side events
Spring 4.2 introduced `ResponseBodyEmitter` for long-lived HTTP connections and streaming the response data. One of
available specialized implementations is `ObservableSseEmitter` that allows to send server side event produced
from `rx.Observable`.
Example:
```
@RestController
public static class Events {
@RequestMapping(method = RequestMethod.GET, value = "/messages")
public ObservableSseEmitter messages() {
return new ObservableSseEmitter(
Observable.just(
"message 1", "message 2", "message 3"
)
);
}
}
```
This will output:
```
data: message 1
data: message 2
data: message 3
```
The SSE can be conveniently consumed by a JavaScript client for instance.
## Properties
The only supported property is `rxjava.mvc.enabled` which allows to disable this extension.
```
rxjava.mvc.enabled=true # true by default
```
## License
Apache 2.0