© 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 

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 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 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 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 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 { void accept(T t); } public interface Supplier { T get(); } public interface Function { V apply(T t); } public abstract class Predicate { boolean test(T t); } 

Reactor – Stream ● Streams allow for composition of functions on data – Callback++ – Netflix RxJava Observable, JDK 8 Stream Stream str; str.map(String::toUpperCase) .filter(new Predicate() { 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 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 proc; Operation 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 @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(); } 

Reactor – Spring @Component public 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