Reactor - a foundation for asynchronous applications on the JVM

5,723 views
5,365 views

Published on

Speakers: Jon Brisbin and Stephane Maldini
Reactor was recently made public after a two-year incubation, evolving slowly alongside frameworks like Storm, Akka, Play, GPars or Vert.x. Integrated with Grails starting with version 2.3, 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.

Published in: Technology

Reactor - a foundation for asynchronous applications on the JVM

  1. 1. Reactor: A Foundation for Reactive FastData Applications on the JVM Jon Brisbin – @j_brisbin Stephane Maldini – @smaldini © 2013 SpringOne 2GX. All rights reserved. Do not distribute without permission.
  2. 2. The Spring IO Directory
  3. 3. Reactor – Housekeeping ● Tweet questions during the presentation – – @j_brisbin – ● @ProjectReactor @smaldini Stop us anywhere if you have a question – There are no stupid questions, only stupid answers!
  4. 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. 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. 6. Reactor – What can I build with it? ● Reactor applications are reactive – – Netflix RxJava – ● Reactive Extensions in .NET 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. 7. Reactor – Landscape
  8. 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. 9. Reactor – Dispatchers ● Dispatchers manage task execution – ThreadPoolExecutorDispatcher ● – BlockingQueueDispatcher ● – Event Loop style RingBufferDispatcher ● – Standard ThreadPoolExecutor LMAX Disruptor RingBuffer SynchronousDispatcher
  10. 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. 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. 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. 13. Reactor – Consumer, Function, Supplier, Predicate public interface Consumer<T> { void accept(T t); } public interface Function<T, V> { V apply(T t); } public interface Supplier<T> { T get(); } public abstract class Predicate<T> { boolean test(T t); }
  14. 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. 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. 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. 17. Reactor – Spring ● Helpers to integrate Reactor into ApplicationContext – @EnableReactor for easy configuration – Wiring annotated handlers
  18. 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. 19. Reactor – Spring @Component public class SimpleHandler { @Autowired private Reactor reactor; @Selector(“test.topic”) public void onTestTopic(String s) { // Handle data } }
  20. 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. 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. 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. 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. 24. Reactor – Groovy : Environment GroovyEnvironment.create { environment { defaultDispatcher = "test" } } dispatcher('test') { type = DispatcherType.SYNCHRONOUS }
  25. 25. Reactor – Groovy : Environment GroovyEnvironment.create { reactor('test1') { stream('test') { consume{ ev-> log.info ev.data } } on('test') { reply it } } }
  26. 26. Reactor – Demo
  27. 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. 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. 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. 30. Reactor – Uber Community contributions ● Meltdown: A Clojure binding by @michaelklishin & @ifesdjeen – https://github.com/clojurewerkz/meltdown
  31. 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. 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

×