Reactor - a foundation for asynchronous applications on the JVM
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share

Reactor - a foundation for asynchronous applications on the JVM

  • 2,129 views
Uploaded on

Speakers: Jon Brisbin and Stephane Maldini ...

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.

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
2,129
On Slideshare
2,129
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
37
Comments
0
Likes
7

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 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. The Spring IO Directory
  • 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. 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 – – 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. 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 ● – BlockingQueueDispatcher ● – Event Loop style RingBufferDispatcher ● – Standard ThreadPoolExecutor 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 Function<T, V> { V apply(T t); } public interface Supplier<T> { T get(); } 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