© 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