© 2013 SpringOne 2GX. All rights reserved. Do not distribute without permission.
Reactor: A Foundation for Reactive FastData Applications on the JVM
Jon Brisbin – @j_brisbinStephane Maldini – @smaldini
The Spring IO Directory
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!
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
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
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
Reactor – Landscape
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”));
Reactor – Dispatchers
● Dispatchers manage task execution
– ThreadPoolExecutorDispatcher● Standard ThreadPoolExecutor
– BlockingQueueDispatcher● Event Loop style
– RingBufferDispatcher● LMAX Disruptor RingBuffer
– SynchronousDispatcher
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
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”));
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”));
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);
}
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));
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));
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());
Reactor – Spring
● Helpers to integrate Reactor into ApplicationContext
– @EnableReactor for easy configuration
– Wiring annotated handlers
Reactor – Spring@Configuration@EnableReactorpublic 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(); }
Reactor – Spring
@Componentpublic class SimpleHandler {
@Autowired private Reactor reactor;
@Selector(“test.topic”) public void onTestTopic(String s) { // Handle data }
}
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
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
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()}
}
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
Reactor – Groovy : Environment
GroovyEnvironment.create {environment {
defaultDispatcher = "test"
dispatcher('test') {type = DispatcherType.SYNCHRONOUS
}}
}
Reactor – Groovy : Environment
GroovyEnvironment.create {reactor('test1') {
stream('test') {consume{ ev->
log.info ev.data}
}on('test') {
reply it}
}}
Reactor – Demo
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
Reactor – Roadmap
● 1.0 feature complete
– 1.0 M3 this morning!
– 1.0 RC1 – within a week
– 1.0 GA – within a month
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
Reactor – Uber Community contributions
● Meltdown: A Clojure binding by @michaelklishin & @ifesdjeen
– https://github.com/clojurewerkz/meltdown
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
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
Recommended
