Reactor - A Foundation for Reactive FastData Applications on the JVM

Reactor takes the best ideas from several asynchronous toolsets and synthesizes them into a coherent framework that supports a variety of runtime topologies and makes it easy for developers to efficiently leverage their cloud or traditional hardware assets. Reactor is equally at home inside or outside a Spring ApplicationContext and also provides first-class Groovy support in the form of DSLs and language extensions. Special attention has been given to make Reactor easy enough to use to create single-file node.js-like applications, while maintaining a solid asynchronous toolset that works with Big and Fast Data tools like Gemfire, Spring Integration, and Spring Batch. This talk will give Reactor a proper introduction and show sample code that demonstrates the event-driven and composition-based nature of Reactor applications.

Transcript

1. © 2013 SpringOne 2GX. All rights reserved. Do not distribute without permission. Reactor: A Foundation for Reactive FastData Applications on the JVM Jon Brisbin – @j_brisbin Stephane Maldini – @smaldini
2. The Spring IO Directory
3. Reactor – Housekeeping • Tweet questions during the presentation – @ProjectReactor – @j_brisbin – @smaldini • Stop us anywhere if you have a question – There are no stupid questions, only stupid answers!
4. Reactor – What is it? • Reactor is a foundational library – Plays in grey area between user-level and lower-level abstractions – Components and application cores can be built on Reactor – Drivers, servers, data integration libraries, domain integration libraries, Evented architectures
5. Reactor – What is it? • Reactor is a distillation of other libraries and best-practices – Elements of other patterns and libraries surface throughout Reactor's abstractions http://stackoverflow.com/questions/16595393/akka-or-reactor
6. Reactor – What can I build with it? • Reactor applications are reactive – Reactive Extensions in .NET – Netflix RxJava – Observer pattern • Reactor applications route events based on a Selector – Like a routing topic, but can be any object – Regex, URI template, Class.isAssingableFrom, custom logic
7. Reactor – Landscape
8. Reactor – What does it look like? Environment env = new Environment(); Reactor reactor = Reactors.reactor() .env(env) .dispatcher(RING_BUFFER) .get(); reactor.on($(“topic”), (Event<String> ev) → { System.out.println(“Hello “ + ev.getData()); }); reactor.notify(“topic”, Event.wrap(“John Doe”));
9. Reactor – Dispatchers • Dispatchers manage task execution – ThreadPoolExecutorDispatcher • Standard ThreadPoolExecutor – BlockingQueueDispatcher • Event Loop style – RingBufferDispatcher • LMAX Disruptor RingBuffer – SynchronousDispatcher
10. Reactor – Selectors • Selectors are the left-hand side of an equality comparison – A Selector can be created from any object using $(obj) (or the long form: Selectors.object(obj)) – A Selector can extract data from the matched key – Predicate<T> Selectors can be created to match on domain-specific criteria like header values
11. Reactor – Selectors • A RegexSelector will match a String by executing the regex over it – R(“some.(.*)”) – Selectors.regex(“some.(.*)”) reactor.on(R(“some.(.+)”), (Event<String> ev) → { // s will be 'topic' String s = ev.getHeaders().get(“group1”); }); reactor.notify(“some.topic”, Event.wrap(“John Doe”));
12. Reactor – Selectors • A UriTemplateSelector will match a String by extracting bits from a URI – U(“/some/{path}”) – Selectors.uri(“/some/{path}”) reactor.on(U(“/some/{topic}”), (Event<String> ev) → { // s will be 'topic' String s = ev.getHeaders().get(“topic”); }); reactor.notify(“/some/topic”, Event.wrap(“John Doe”));
13. Reactor – Consumer, Function, Supplier, Predicate public interface Consumer<T> { void accept(T t); } public interface Supplier<T> { T get(); } public interface Function<T, V> { V apply(T t); } public abstract class Predicate<T> { boolean test(T t); }
14. Reactor – Stream • Streams allow for composition of functions on data – Callback++ – Netflix RxJava Observable, JDK 8 Stream Stream<String> str; str.map(String::toUpperCase) .filter(new Predicate<String>() { public boolean test(String s) { … } }) .consume(s → log.info(“consumed string {}”, s));
15. Reactor – Promise • Promises allow for composition of functions on data – Share common functions with Stream Promise<String> p; String s = p .onSuccess(s → log.info(“consumed string {}”, s)) .onFailure(t → log.error(t.getMessage(), t)) .onComplete(t → log.info(“complete”)) .await(5, SECONDS); p.map(String::toUpperCase).consume(s → log.info(“UC: {}”, s));
16. Reactor – Processor • Thin wrapper around Disruptor RingBuffer – Converts Disruptor API to Reactor API – Uber fast performance for #UberFastData Processor<Buffer> proc; Operation<Buffer> op = proc.prepare(); op.get().append(data).flip(); op.commit(); proc.batch(512, buff → buff.append(data).flip());
17. Reactor – Spring • Helpers to integrate Reactor into ApplicationContext – @EnableReactor for easy configuration – Wiring annotated handlers
18. Reactor – Spring @Configuration @EnableReactor public class ReactorConfiguration { @Bean public Reactor input(Environment env) { return Reactors.reactor().env(env) .dispatcher(RING_BUFFER).get(); } @Bean public Reactor output(Environment env) { return Reactors.reactor().env(env) .dispatcher(RING_BUFFER).get(); }
19. Reactor – Spring @Component public class SimpleHandler { @Autowired private Reactor reactor; @Selector(“test.topic”) public void onTestTopic(String s) { // Handle data } }
20. Reactor – Spring • DispatcherTaskExecutor – Not really a high-scale TaskExecutor – Used to get Spring components running in same thread as Reactor Consumers • ConversionService integration • PromiseHandlerMethodReturnValueHandler (!) • ReactorSubscribableChannel
21. Reactor – Groovy • First class citizen language implementation – @CompileStatic ready – Prominent use of Closure as Consumers, Functions and more – Operator overloading for elegant programming – Full Reactor system Builder
22. Reactor – Groovy : Notification and Consumer @CompileStatic def welcome(){ reactor.on('greetings') { String s -> reply “hello $s” reply “how are you?” } reactor.notify 'greetings', 'Jon' reactor.send('greetings', 'Stephane'){ println it cancel() } }
23. Reactor – Groovy : Promises and Streams def promise = Promises.task { longStuff(); 1 } get() def transformation = c | { it + 1 } transformation.await() == 2 def deferredStream = Streams.defer().get() (deferredStream & { it > 2 }) << { send(it) } deferredStream << 1 << 2 << 3 << 4
24. Reactor – Groovy : Environment GroovyEnvironment.create { environment { defaultDispatcher = "test" dispatcher('test') { type = DispatcherType.SYNCHRONOUS } } }
25. Reactor – Groovy : Environment GroovyEnvironment.create { reactor('test1') { stream('test') { consume{ ev-> log.info ev.data } } on('test') { reply it } } }
26. Reactor – Demo
27. Reactor – Extensive awesomeness • TCP Client/Server, with a Netty 4 implementation • Buffer tools • Sequencer support, for event ordering • Work Queue support, with OOTB Java Chronicle implementation • Logback Appender
28. Reactor – Roadmap • 1.0 feature complete – 1.0 M3 this morning! – 1.0 RC1 – within a week – 1.0 GA – within a month
29. Reactor – Roadmap 1.1 Discussions – StateBox: A safe tool for concurrent writes – Better Timer management – Spring XD, Spring 4 – Exploring Distributed Reactors • Voice your interest and your use-case here – MillWheel: Fault-Tolerant Stream Processing at Internet Scale http://db.disi.unitn.eu/pages/VLDBProgram/pdf/industry/p734-akidau.pdf
30. Reactor – Uber Community contributions • Meltdown: A Clojure binding by @michaelklishin & @ifesdjeen – https://github.com/clojurewerkz/meltdown
31. Reactor – Uber Community contributions • High Performance Couchbase ingestion by @daschl – http://nitschinger.at/Using-the-Reactor-Processor-for-High-Performance-TCP • Benefits of using Reactor Processor, TCP and Batching facilities
32. Learn More. Stay Connected. • Github organization : http://github.com/reactor • Follow-up: – Spring XD – Spring 4 WebSocket – Grails and the realtime web Talk to us on Twitter: @ProjectReactor @springcentral Find Session replays on YouTube: spring.io/video