Groovy reactor grails realtime web devoxx 2013

Guillaume Laforge @glaforge !

Groovy, Reactor, Grails & the realtime web

Stéphane Maldini@smaldini !

Stéphane Maldini

Consultant and Reactor committer at .

!

@smaldini

Guillaume Laforge

Groovy project lead at .

!

@glaforge http://glaforge.appspot.com

http://glaforge.appspot.com

Les Cast Codeurs

Introduction

Part 0

Valuable usersdon’t like to wait

Realtime webapplications are about

the « now »

Show users liveupdates as they come


A « push » approach vs a« pull » approach


Handle a bigvolume of events



Handle a bigvolume of events React fast to

new events




new events


Use promises, events,streams to react fast and

stream updates to users asthey are ready



new events




Avoid blockingand state



new events

Fail gracefully




Avoid blockingand state

Sharp tools:Groovy, Reactor &

Grails

Groovy

Part 1

Groovy…

an Open Source alternative language

for the JVM

Groovy…

Object-oriented, dynamic, with a functional flavor

Groovy…

But also supports static type checking &

static compilation

million downloadsper year1.7

Yup, we’re allusing Groovy!

Simplify the life of(Java) developers

Groovy as a Javasuperset

It’s so easy tolearn!

Groovy as a Javasuperset

As safe and fast as Java withstatic type checking & compilation

new MarkupBuilder().html { head { title "The Script Bowl" } !

body { div(class: "banner") { p "Groovy rocks!" } } }

move forward at 3.km/h

Expressive,Concise,Readable

@RestController class App { @RequestMapping("/") String home() { "Hello World!" } }

Speaking of conciseness...A full Spring app in the span of a tweet!

Great forscripting

Great forscripting

Fit for Domain-SpecificLanguages

Great forscripting


Most seamless integration &interoperability wih java!

Great forscripting


Most seamless integration &interoperability wih java!

Full-blown reactiveapplications too!

Most Java code is alsovalid Groovy code!

Any Java developer is aGroovy developer!

Most Java code is alsovalid Groovy code!

Flat learningcurve

Flat learningcurve

Easy to learn

@glaforge — @smaldini / #DV13-rtweb

Scripts versus Classes

!26

public class Main { public static void main(String[] args) { System.out.println("Hello"); } }

vs


Scripts versus Classes

!26

public class Main { public static void main(String[] args) { System.out.println("Hello"); } }

println "Hello"

vs

Optional

Optional

Semicolons

Optional

SemicolonsParentheses

Optional


return keyword

Optional


return keyword public keyword

Optional


return keyword public keyword

Typing!


Optional...

!28

public class Greeter { private String owner; ! public String getOwner() { return owner; } ! public void setOwner(String owner) { this.owner = owner; } ! public String greet(String name) { return "Hello " + name + ", I am " + owner; } } !Greeter greeter = new Greeter(); greeter.setOwner("Guillaume"); !System.out.println(greeter.greet("Marion"));


Optional...

!28


Semicolons


Optional...public class Greeter { private String owner ! public String getOwner() { return owner } ! public void setOwner(String owner) { this.owner = owner } ! public String greet(String name) { return "Hello " + name + ", I am " + owner } } !Greeter greeter = new Greeter() greeter.setOwner("Guillaume") !System.out.println(greeter.greet("Marion"))

!29



!30



Parentheses

!30


Optional...

!31

public class Greeter { private String owner ! public String getOwner() { return owner } ! public void setOwner(String owner) { this.owner = owner } ! public String greet(String name) { return "Hello " + name + ", I am " + owner } } !Greeter greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")


Optional...

!31

public class Greeter { private String owner ! public String getOwner() { return owner } ! public void setOwner(String owner) { this.owner = owner } ! public String greet(String name) { return "Hello " + name + ", I am " + owner } } !Greeter greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")

return keyword


Optional...

!32

public class Greeter { private String owner ! public String getOwner() { owner } ! public void setOwner(String owner) { this.owner = owner } ! public String greet(String name) { "Hello " + name + ", I am " + owner } } !Greeter greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")


Optional...

!32

public class Greeter { private String owner ! public String getOwner() { owner } ! public void setOwner(String owner) { this.owner = owner } ! public String greet(String name) { "Hello " + name + ", I am " + owner } } !Greeter greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")

public keyword


Optional...

!33

class Greeter { private String owner ! String getOwner() { owner } ! void setOwner(String owner) { this.owner = owner } ! String greet(String name) { "Hello " + name + ", I am " + owner } } !Greeter greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")


Optional...

!33

class Greeter { private String owner ! String getOwner() { owner } ! void setOwner(String owner) { this.owner = owner } ! String greet(String name) { "Hello " + name + ", I am " + owner } } !Greeter greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")

optional typing


Optional...

!34

class Greeter { private String owner ! String getOwner() { owner } ! void setOwner(String owner) { this.owner = owner } ! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")


Optional...

!34

class Greeter { private String owner ! String getOwner() { owner } ! void setOwner(String owner) { this.owner = owner } ! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.setOwner "Guillaume" !System.out.println greeter.greet("Marion")

handy println shortcut


Optional...

!35

class Greeter { private String owner ! String getOwner() { owner } ! void setOwner(String owner) { this.owner = owner } ! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.setOwner "Guillaume" ! println greeter.greet("Marion")


Optional...

!35

class Greeter { private String owner ! String getOwner() { owner } ! void setOwner(String owner) { this.owner = owner } ! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.setOwner "Guillaume" ! println greeter.greet("Marion")

verbose Java properties!


Optional...

!36

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.setOwner "Guillaume" ! println greeter.greet("Marion")


Optional...

!36

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.setOwner "Guillaume" ! println greeter.greet("Marion")

Property notation


Optional...

!37

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.owner = "Guillaume" ! println greeter.greet("Marion")


Optional...

!37

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter() greeter.owner = "Guillaume" ! println greeter.greet("Marion")

Named argumentconstructor


Optional...

!38

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter(owner: "Guillaume") !! println greeter.greet("Marion")


Optional...

!38

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello " + name + ", I am " + owner } } !def greeter = new Greeter(owner: "Guillaume") !! println greeter.greet("Marion")

Interpolated strings!(aka GStrings)


Optional...

!39

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello ${name}, I am ${owner}" } } !def greeter = new Greeter(owner: "Guillaume") !! println greeter.greet("Marion")


Optional...

!39

class Greeter { String owner !!!!!!!!! String greet(String name) { "Hello ${name}, I am ${owner}" } } !def greeter = new Greeter(owner: "Guillaume") !! println greeter.greet("Marion")

Let’s reformat that messof whitespace!


Optional...

!40

class Greeter { String owner ! String greet(String name) { "Hello ${name}, I am ${owner}" } } !def greeter = new Greeter(owner: "Guillaume") !println greeter.greet("Marion")


Optional...

!40




Native syntax constructs

!41

// closures def adder = { a, b -‐> a + b } !

// lists def list = [1, 2, 3, 4, 5] !

// maps def map = [a: 1, b: 2, c: 3] !

// regular expressions def regex = ~/.*foo.*/ !

// ranges def range 128..255


Closures — the basics

• Functions as first-class citizen of the language

!42

def adder = { a, b -‐> a + b } !

assert adder(1, 2) == 3 assert adder('a', 'b') == 'ab'




!42

def adder = { a, b -‐> a + b } !


Closureparameters




!42

def adder = { a, b -‐> a + b } !


Assign a functioninto a variable

Closureparameters




!42

def adder = { a, b -‐> a + b } !


Short form of:adder.call(‘a’, ‘b’)


Closureparameters




!42

def adder = { a, b -‐> a + b } !


Short form of:adder.call(‘a’, ‘b’)

Genericity withduck typing & operator

overloading


Closureparameters


Closures — explicit type

!43

!

def intAdder = { int a, int b -‐> a + b }


Closures — explicit type

!43

!

def intAdder = { int a, int b -‐> a + b }

Be explicit aboutthe types


Closures — implicit parameter

!44

def doubler = { it * 2 } !

assert doubler(3) == 6 assert doubler('a') == 'aa'



!44



Implicitparameter



!44



Implicitparameter

Multiply also definedon strings


Closures — variable arguments

!45

def sum = { ... elements -‐> elements.sum() } !

assert sum(1, 2) == 3 assert sum('a', 'b', 'c') == 'abc'



!45



Variable number ofarguments



!45



You can specify thetype: int...

Variable number ofarguments


Closures — default values

!46

def mult = { int a, int b = 10 -‐> a * b } !

assert mult(2, 3) == 6 assert mult(5) == 50



!46



Default value



!46



Default value

Provided valuefor b



!46



Default value

Provided valuefor b

Default valueused for b


Closures — methods as functions

!47

def logBase10 = Math.&log10 def printer = System.out.&println !

assert logBase10(10) == 1 printer 'abc'


Closures — methods as functions

!47

def logBase10 = Math.&log10 def printer = System.out.&println !

assert logBase10(10) == 1 printer 'abc'

Turn a method into a closure function


Closures — map / filter / reduce

!48



!48

@groovy.transform.Immutableclass Person { String name int age}



!48


def persons = [ new Person('Guillaume', 36), new Person('Marion', 5), new Person('Erine', 1)]



!48



def names = persons.findAll { it.age < 18 } .collect { it.name.toUpperCase() } .sort() .join(', ')



!48




assert names == "ERINE, MARION"



!48




assert names == "ERINE, MARION"

find/findAll, inject, collect, flatten, min/max, unique, reverse, collate, groupBy, any/every, head/tail/last,

count/countBy, combinations/permutations/subsequences/

transpose, withDefault/withLazyDefault


Closures — resource handling

!49

new File('bible.txt').withReader { r -‐> new File('out.txt').withWriter { w -‐> r.eachLine { line -‐> if (line.contains('Groovy')) w << line.toUpperCase() } } }


Closures — resource handling

!49

new File('bible.txt').withReader { r -‐> new File('out.txt').withWriter { w -‐> r.eachLine { line -‐> if (line.contains('Groovy')) w << line.toUpperCase() } } }

Take care of properly opening /closing resources


Closures — custom control structures

!50

void unless(boolean cond, Closure c) { if (!cond) c() } !

unless (10 < 9) { println "less" }



!50



Closure as last argument



!50



Closure as last argument

Equivalent to:unless(10<9, {...})



!51

class Reactor { void on(Selector s, Closure c) { … } } … reactor.on( $(‘abc') ) { Event<String> ev -‐> … }


Closures — builders leverage closures

!52

import groovy.json.* !

def json = new JsonBuilder() json.person { name 'Guillaume' age 36 daughters 'Marion', 'Erine' address { street '1 Main Street' zip 75001 city 'Paris' } }



!52



Hierarchical datarepresentation



!52




Closure blocksdelimiting the

structure



!52




Closure blocksdelimiting the

structure

{ "person": { "name": "Guillaume", "age": 36, "daughters": [ "Marion", "Erine" ], "address": { "street": "1 Main Street", "zip": 75001, "city": "Paris" } } }


Closure — your own builders

!53

GroovyEnvironment.create { environment { defaultDispatcher = "test" !

dispatcher('test') { type = DispatcherType.SYNCHRONOUS } } }



!53



Implement a builder extendingBuilderSupport or FactoryBuilderSupport…

or roll your own!



!53



abstract class BuilderSupport { abstract void setParent(Object parent, Object child) abstract Object createNode(Object name) abstract Object createNode(Object name, Object value) abstract Object createNode(Object name, Map attributes) abstract Object createNode(Object name, Map attributes, Object value) }

Implement a builder extendingBuilderSupport or FactoryBuilderSupport…

or roll your own!


GPath expressions

• GPath expressions are like XPath but for an object graph

!54


def url = "https://api.github.com/repos/groovy/groovy-‐core/commits" !

def commits = new JsonSlurper().parseText(url.toURL().text) !

assert commits[0].commit.author.name == 'Cedric Champeau'


GPath expressions


!54





GPath expression


GPath expressions


!54





GPath expression Add find / findAllinto the mix


GPath expressions


!54





GPath expression Add find / findAllinto the mix

No (un)marshalling!


Lists

!55

def list = ['a', 'b', 'c'] !

list << 'd' assert list.contains('d') !

assert list.findAll { it.startsWith 'a' }.size() == 1 assert list.collect { it.toUpperCase() } == ['A', 'B', 'C', 'D'] assert list.inject('') { a, b -‐> a + b } == 'abcd'


Lists

!55

def list = ['a', 'b', 'c'] !



List definition


Lists

!55

def list = ['a', 'b', 'c'] !



List definition

Append an element(operator overloading)


Lists

!55

def list = ['a', 'b', 'c'] !



List definition

Append an element(operator overloading)

Functional-style map /filter / reduce with

closures


Maps

!56

def map = [name: 'Guillaume', age: 36] !

map.daughters = ['Marion', 'Erine'] !

assert map['daughters'].contains('Marion')


Maps

!56




Map definition


Maps

!56




Map definition

Indexed access


Maps

!56




Map definition

Indexed accessProperty notationaccess


Regular expressions

!57

def pattern = ~/.*foo.*/ !

assert "Alibaba" ==~ /.*(ba){2}/ !

def matcher = "Superman" =~ /([A-‐Z][a-‐z]+)man/ assert matcher[0][0] == 'Superman' assert matcher[0][1] == 'Super' !

'75001 Paris'.find(/(\d{5})\s(\w+)/) { match, zip, town -‐> println "The Zip code of ${town} is ${zip}" }


Regular expressions

!57





Pattern


Regular expressions

!57





PatternMatch


Regular expressions

!57





PatternMatch

Find


Regular expressions

!57





PatternMatch

Find

Nice way to decompose the matched regions


Ranges

!58

def range = 'a'..'z' !

assert range.contains('m') assert range.contains('z') !

def exclusive = 1..<10 !

assert !exclusive.contains(10) !

def reverse = 10..0 !

assert reverse[0] == 10 assert reverse[-‐1] == 0


Ranges

!58







Range


Ranges

!58







Range

Excluded upper bound


Ranges

!58







Range


Reverse range


Ranges

!58







Range


Reverse range

Negative index countfrom the end


Strings, GStrings, multiline strings

!59

def name = 'Groovy' def tmpl = """ Dear Mr ${name}, You're the winner of the lottery! Yours sincerly, Dave """ !

assert tmpl.toString().contains('Groovy')



!59



Plain java.lang.String



!59



Plain java.lang.String

Multiline string withexpression interpolation


Surprising numbers...

!60

System.out.println( 2.0 -‐ 1.1 );



!60

System.out.println( 2.0 -‐ 1.1 );

0.8999999999999999



!61

System.out.println( 3 / 2 );



!61

System.out.println( 3 / 2 );

1


BigDecimal by default!

!62

assert 2.0 -‐ 1.1 == 0.9

assert 3 / 2 == 1.5



!62

assert 2.0 -‐ 1.1 == 0.9

assert 3 / 2 == 1.5

One of the reasons why micro-benchmarks sometimes showed

Groovy to be slow...



!62

assert 2.0 -‐ 1.1 == 0.9

assert 3 / 2 == 1.5

One of the reasons why micro-benchmarks sometimes showed

Groovy to be slow...

But you can use doubles & floats forperformance, with ‘d’ or ‘f ’ suffixes

or with explicit type

Powerful switch /case on steroids

Powerful switch /case on steroids

switch(obj) { case 123: "number 123"; break case "abc": "string abc"; break case String: "is a string"; break case [1, 2, 3]: "in list"; break case ~/.*o+.*/: "regex match"; break case { it < 3 }: "closure criteria"; break default: "unknown" }


Named arguments

!64

move obj, x: 3, y: 4


Named arguments

!64


Normal argument


Named arguments

!64


Normal argument Named argument


Named arguments

!64


Normal argument Named argument

Calls:move(Map m, Object)


Command chains

• Ability to chain method calls without parentheses and dots

!65



Command chains

• Ability to chain method calls without parentheses and dots

!65


Actually equivalent to:move(forward).at(3.getKm().div(h))


Named arguments & command chains

!66

check that: vodka tastes good


Named arguments & command chains

!66

check that: vodka tastes good

Will call:check(that: vodka).tastes(good)


Multiple assignment and destructuring

!67

def (a, b) = ['A', 'B'] !

(a, b) = [b, a] !

def (int i, int j) = [1, 2] !

def geocode(String place) { return [45.4, 2.3] } !

def (la, lo) = geocode("Paris") !

assert la == 45.4 && lo == 2.3



!67

def (a, b) = ['A', 'B'] !

(a, b) = [b, a] !

def (int i, int j) = [1, 2] !



assert la == 45.4 && lo == 2.3

Classic « swap »



!67

def (a, b) = ['A', 'B'] !

(a, b) = [b, a] !

def (int i, int j) = [1, 2] !



assert la == 45.4 && lo == 2.3

Classic « swap »With types



!67

def (a, b) = ['A', 'B'] !

(a, b) = [b, a] !

def (int i, int j) = [1, 2] !



assert la == 45.4 && lo == 2.3


Methodreturning a list



!67

def (a, b) = ['A', 'B'] !

(a, b) = [b, a] !

def (int i, int j) = [1, 2] !



assert la == 45.4 && lo == 2.3


Methodreturning a list

Destructuring



!68

class Point { double x, y !

double getAt(int idx) { if (idx == 0) x else if (idx == 1) y else throw new Exception("Wrong index") } } !

def (x, y) = new Point(x: 48.3, y: 3.5) !

assert x == 48.3 && y == 3.5



!68




assert x == 48.3 && y == 3.5

Method signatureconvention: getAt(int)



!68




assert x == 48.3 && y == 3.5

Method signatureconvention: getAt(int)

Transparent destructuring


Operator overloading

!69

import static Unit.* !enum Unit { M(1), KM(1000) ! double mult Unit(double mult) { this.mult = mult } }



!69


import groovy.transform.Immutable import static Unit.* !@Immutable class Distance { double q Unit u ! Distance plus(Distance d) { new Distance( q * u.mult + d.q * d.u.mult, M) } }



!69



import static Unit.* !def d10 = new Distance(10, M) def d15 = new Distance(15, M) !def d25 = d10 + d15 !assert d25.q == 25 && d25.u == M



!69




Overload the ‘+’operator



!69




Overload the ‘+’operator

Use ‘+’



!70

a + b // a.plus(b) a -‐ b // a.minus(b) a * b // a.multiply(b) a / b // a.div(b) a % b // a.modulo(b) a ** b // a.power(b) a | b // a.or(b) a & b // a.and(b) a ^ b // a.xor(b) a[b] // a.getAt(b) a << b // a.leftShift(b) a >> b // a.rightShift(b) a >>> b // a.rightShiftUnsigned(b) +a // a.unaryPlus() -‐a // a.unaryMinus() ~a // a.bitwiseNegate()



!70

a + b // a.plus(b) a -‐ b // a.minus(b) a * b // a.multiply(b) a / b // a.div(b) a % b // a.modulo(b) a ** b // a.power(b) a | b // a.or(b) a & b // a.and(b) a ^ b // a.xor(b) a[b] // a.getAt(b) a << b // a.leftShift(b) a >> b // a.rightShift(b) a >>> b // a.rightShiftUnsigned(b) +a // a.unaryPlus() -‐a // a.unaryMinus() ~a // a.bitwiseNegate()

Operator overloading isjust a convention on

method names


Power asserts

!71

def (a, b, c) = [20, 30, 40] !

assert a * (b -‐ 1) / 10 == 3 * c / 2 + 1


Power asserts

!71

def (a, b, c) = [20, 30, 40] !

assert a * (b -‐ 1) / 10 == 3 * c / 2 + 1

Assertion failed: !

assert a * (b -‐ 1) / 10 == 3 * c / 2 + 1 | | | | | | | | | | | 580| 29 58 false| | 60 61 20 30 | 40 120 !

at script1.run(script1.groovy:3)


Power asserts

!71

def (a, b, c) = [20, 30, 40] !

assert a * (b -‐ 1) / 10 == 3 * c / 2 + 1

Assertion failed: !

assert a * (b -‐ 1) / 10 == 3 * c / 2 + 1 | | | | | | | | | | | 580| 29 58 false| | 60 61 20 30 | 40 120 !

at script1.run(script1.groovy:3)Invented by the Spock testing framework


Null handling

!72

class Order { LineItem line } class LineItem { int quantity Item item } class Item { String name } !

def o = new Order( line: new LineItem( quantity: 2, item: null)) !

println o.line.item.name


Null handling

!72




With Java, you only get an NPE. No idea where it came from!


Null handling

!72




With Java, you only get an NPE. No idea where it came from!

Groovy will say: Cannot get property ‘name’ on null object


Null handling

!72





Null handling

!72




o?.line?.item?.name


Null handling

!72




o?.line?.item?.name

Safe navigation:will just return

null; No NPE

The Truth,the Groovy Truth!

The Truth,the Groovy Truth!

And what if I couldcustomize the truth?


The Groovy Truth

!74

assert !( null ) assert !( "" ) assert !( [] ) assert !( 0 )

assert new Object() assert "string" assert [1, 2, 3] assert 1234


The Groovy Truth

!74



null, empty, 0-sized, zeroare coerced to false


The Groovy Truth

!74



null, empty, 0-sized, zeroare coerced to false

true otherwise


Customizing the truth!

!75

class Account { String name boolean disabled = false !

boolean asBoolean() { !disabled } } !

assert new Account(name: 'current') assert !new Account(name: 'old', disabled: true)


Customizing the truth!

!75

class Account { String name boolean disabled = false !

boolean asBoolean() { !disabled } } !

assert new Account(name: 'current') assert !new Account(name: 'old', disabled: true)

while (account), if (account), etc…

The Elvisoperator!

?:


Towards Elvis...

!77


Towards Elvis...

!77

def (x, y) = ['MacBook Pro', 'unknown']


Towards Elvis...

!77


if (x != null && x.size() > 0) x else y


Towards Elvis...

!77


if (x != null && x.size() > 0) x else yif (x && x.size()) x else y


Towards Elvis...

!77


if (x != null && x.size() > 0) x else yif (x && x.size()) x else yif (x) x else y


Towards Elvis...

!77


if (x != null && x.size() > 0) x else yif (x && x.size()) x else yif (x) x else yx ? x : y


Towards Elvis...

!77


if (x != null && x.size() > 0) x else yif (x && x.size()) x else yif (x) x else yx ? x : yx ?: y


Towards Elvis...

!77



Null, empty, zero-sized... false,

otherwise true!


Towards Elvis...

!77




otherwise true!

Good old ternaryoperator


Towards Elvis...

!77




otherwise true!

Good old ternaryoperatorElvis!


AST transformations

• Abstract Syntax Tree – in memory representation of your program

before being compiled into bytecode !

• AST transformation == process of transforming the AST of a program before it’s compiled !

• Macro-like compiler hook!

!78


Lots of AST transformations...

• Code generation

– @ToString, @EqualsAndHashCode, @Canonical, @TupleConstructor, @InheritConstructors, @Category, @IndexedProperty, @Lazy, @Newify

• Class design

– @Delegate, @Immutable, @Memoized, @Singleton, @Mixin

• Logging

– @Log, @Log4j, @Log4j2, @Slf4j

!79



• Safer scripting

– @ConditionalInterrupt, @ThreadInterrupt, @TimedInterupt

• Compiler directives

– @Field, @PackageScope, @AnnotationCollector, @DelegatesTo, @TypeChecked, @CompileStatic, @CompileDynamic

• Swing patterns

– @Bindable, @ListenerList, @Vetoable

!80



• Dependencies handling

– @Grab, @GrabConfig, @GrabExclude, @GrabResolver

• Test assistance

– @NotYetImplemented, @ASTTest

!81


Immutability

• Implement immutability by the book !

– final class – tuple-style constructor – private final backing fields – defensive copying of collections – equals() and hashCode() methods – toString() method – ...

!82


Immutability

• Implement immutability by the book !

– final class – tuple-style constructor – private final backing fields – defensive copying of collections – equals() and hashCode() methods – toString() method – ...

!82

Can be error-prone towrite immutableclasses oneself !


Immutability

• A Person class with – a String name – an int age

!83

public final class Person {! private final String name;! private final int age;!! public Person(String name, int age) {! this.name = name;! this.age = age;! }!! public String getName() {! return name;! }!! public int getAge() {! return age;! }!! public int hashCode() {! return age + 31 * name.hashCode();! }!! public boolean equals(Object other) {! if (other == null) {! return false;! }! if (this == other) {! return true;! }! if (Person.class != other.getClass()) {! return false;! }! Person otherPerson = (Person)other;! if (!name.equals(otherPerson.getName()) {! return false;! }! if (age != otherPerson.getAge()) {! return false;! }! return true;! }!! public String toString() {! return "Person(" + name + ", " + age + ")";! }!}!


Immutability


!83


Damnverbose

Java!


Immutability


!83


Damnverbose

Java!

Although it’s also avalid Groovy

program!


@Immutable

!84

import groovy.transform.* !

@Immutable class Person { String name int age }


Memoization

• Cache the result of previous invocations of closures or methods with the same set of argument values

!85


@Memoized long fib(long n) { if (n == 0) 0 else if (n == 1) 1 else fib(n -‐ 1) + fib(n -‐ 2) } !

println fib(40)


Memoization

• Cache the result of previous invocations of closures or methods with the same set of argument values

!85


@Memoized long fib(long n) { if (n == 0) 0 else if (n == 1) 1 else fib(n -‐ 1) + fib(n -‐ 2) } !

println fib(40)

Best applied toside-effect free

functions

Groovy allows youto be lazy


The compiler will dothe job for you



More concise, morereadable code



More concise, morereadable code

Less stuff to maintainand worry about


@TypeChecked & @CompileStatic

• Static type checking with @TypeChecked, throws compilation errors on... – typos in method and variable names – incompatible return types – wrong type assignments !

• Supports fine-grained type inference – « Least Upper Bound » – « Flow typing »

!87





!87

You can even extend thestatic type checker!





!87

You can even extend thestatic type checker!

Type check DSLs ordynamic features!



!

• What is type checked can also be compiled statically with @CompileStatic

!

– generate the same bytecode as javac !

– same performance as Java

!88


Static compilation performance

!89

Fibonacci Pi (π) quadrature

Binarytrees

Java 191 ms 97 ms 3.6 s

Staticcompilation 197 ms 101 ms 4.3 s

Primitive optimizations 360 ms 111 ms 23.7 s

No prim.optimizations 2590 ms 3220 ms 50.0 s1.

71.

82.

x

Reactor

Part 2

@glaforge — @smaldini / #DV13-rtweb@glaforge — @smaldini / #DV13-rtweb

Reactor — Housekeeping

!

• Tweet questions during the presentation – @ProjectReactor

!

• Stop us anywhere if you have a question – There are no stupid questions, only stupid answers!

!91


Reactor — Reactive Architecture ?

!92



!92

REACTIVE



!92

EVENT DRIVEN

REACTIVE



!92

EVENT DRIVENAGILE

REACTIVE



!92

EVENT DRIVENAGILE

REACTIVE

SCALABLE



!92

EVENT DRIVENAGILE

REACTIVE

SCALABLE

AVAILABLE



!93

• A good description is available on: http://www.reactivemanifesto.org/ !

• Functional Programming helps as it is stimulus based by nature !

• Groovy is a perfect candidate: Closures and DSL are first class citizen !

• Reactor completes the picture by providing abstractions

http://www.reactivemanifesto.org/


Reactor — Threading model matters

!94

• Context switching hurts performances

• Locking hurts performances

• Message passing hurts performances

• Blocking for a thread hurts performances

• Creating Threads needs memory


Reactor — Dealing with performances

!95

• Actors solve the locking and context switching issues by becoming state boxes • One thread assigned per consumer • One thread will ever access a property

• Non Blocking Programming solves thread creation and waiting issues by delaying logic • Callback will be executed when possible (Lazy) • Reallocate the blocking time to process something else


Reactor — LMAX Disruptor and Ring Buffer

!96

• LMAX Disruptor deals with message passing issues • Based on a Ring Buffer structure • “Mechanical Sympathy” in Disruptor

!

• http://lmax-exchange.github.com/disruptor/files/Disruptor-1.0.pdf

• http://mechanitis.blogspot.co.uk/2011/06/dissecting-disruptor-whats-so-special.html

http://lmax-exchange.github.com/disruptor/files/Disruptor-1.0.pdf

http://mechanitis.blogspot.co.uk/2011/06/dissecting-disruptor-whats-so-special.html


Reactor — Disruptor performances

!97


Reactor — Trisha’s pretty picture of Disruptor

!98

http://mechanitis.blogspot.co.uk/2011/07/dissecting-disruptor-writing-to-ring.html

http://mechanitis.blogspot.co.uk/2011/07/dissecting-disruptor-writing-to-ring.html


Reactor — In love with Disruptor

!99

• Reactor best performances are derived from LMAX Disruptor !

• LMAX Disruptor can be considered as an evolution of the Actor Model: !

• Still avoid locking and deals with context switching • Producer/Consumer decoupled • Add Pipelining, Batching and more


Reactor — A foundation part of Spring IO

!100


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

!101

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

!102


Reactor — Landscape

!103


Reactor — What does it look like?

!104

def env = new Environment() !def reactor = Reactors.reactor().env(env).dispatcher(RING_BUFFER).get() !reactor.on($('topic')){ Event<String> ev -‐> println "Hello $ev.data" } !reactor.notify('topic', Event.wrap('John Doe'))



!104


Create a reactor context



!104


Create a reactor contextBuild a reactor

parameter



!104



Trigger reactor ‘topic’ key

Build a reactorparameter



!104



Trigger reactor ‘topic’ key

React on ‘topic’ events

Build a reactorparameter


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

!105


Reactor — RegexSelector

• A RegexSelector will match a String by executing the regex over it – R(“some.(.*)”) – Selectors.regex(“some.(.*)”)

!106



!

• A RegexSelector will match a String by executing the regex over it !

– R(“some.(.*)”) !

– Selectors.regex(“some.(.*)”)

!107



!108

reactor.on(R('some.(.+)')){ Event<String> ev -‐> def s = ev.headers.get('group1') } !

reactor.notify('some.topic', Event.wrap('John Doe'))



!108



Use a Regex Selector and capture group



!108




Notify a simple Stringkey to be matched



!108




Notify a simple Stringkey to be matched

s will be ‘topic’


Reactor — UriSelector

• A UriTemplateSelector will match a String by extracting bits from a URI !

– U(“/some/{path}”) – Selectors.uri(“/some/{path}”)

!109



!110

reactor.on(U('/some/**/{topic}')){ Event<String> ev -‐> def s = ev.headers['topic'] } !

reactor.notify('/some/to/topic', Event.wrap('John Doe'))



!110



Use a URI Selector and capture fragment



!110




Notify a simple StringURI key to be matched



!110




Notify a simple StringURI key to be matched

s will be ‘topic’


Reactor — Consumer, Function, Supplier, Predicate

!111

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); }



!111





Generic Callback



!111





Generic Callback

Object Factory



!111





Generic Callback

Object Factory

Map Operation



!111





Generic Callback

Object Factory

Map Operation

Filter Operation


Reactor — Streams

● Streams allow for composition of functions on data − Callback++ − Netflix RxJava Observable, JDK 8 Stream

!112

Stream<String> str = obtainStream() !

str.map{ it.toUpperCase() } .filter{ someCondition() } .consume{ s -‐> log.info "consumed string $s" }


Reactor — Streams


!112



Coerces to Function


Reactor — Streams


!112



Coerces to Predicate

Coerces to Function


Reactor — Streams


!112



Coerces to Predicate

Coerces to Function

Coerces to Consumer


Reactor — Promises

● Promises supersedes Java Future for composition − Share common functions with Stream − Stateful: only 1 transition allowed

!113

Promise<String> p = doLater() !

String s = p .onSuccess { s -‐> log.info "consumed string $s" } .onFailure { t -‐> log.error "$t.message" } .onComplete { log.info 'complete' } .await(5, SECONDS) !

p.map{ it.toUpperCase() }.consume{s -‐> log.info "UC: $s"}


Reactor — Promises

● Promises supersedes Java Future for composition − Share common functions with Stream − Stateful: only 1 transition allowed

!113

Promise<String> p = doLater() !

String s = p .onSuccess { s -‐> log.info "consumed string $s" } .onFailure { t -‐> log.error "$t.message" } .onComplete { log.info 'complete' } .await(5, SECONDS) !

p.map{ it.toUpperCase() }.consume{s -‐> log.info "UC: $s"} Block for a return value


Reactor — Processor● Thin wrapper around Disruptor RingBuffer − Converts Disruptor API to Reactor API − Uber fast performance for #UberFastData

!114

Processor<Buffer> proc !

Operation<Buffer> op = proc.prepare() op.get().append(data).flip() op.commit() !

proc.batch(512) { it.append(data).flip() }


Reactor — Processor● Thin wrapper around Disruptor RingBuffer − Converts Disruptor API to Reactor API − Uber fast performance for #UberFastData

!114

Processor<Buffer> proc !

Operation<Buffer> op = proc.prepare() op.get().append(data).flip() op.commit() !

proc.batch(512) { it.append(data).flip() }

Fill 512 slots and release once


Reactor — Spring

!

● Helpers to integrate Reactor into ApplicationContext !

− @EnableReactor for easy configuration !

− Wiring annotated handlers

!115


Reactor — Spring

!116

@Configuration @EnableReactor class ReactorConfiguration { !

@Bean Reactor input(Environment env) { Reactors.reactor().env(env) .dispatcher(RING_BUFFER).get() } !

@Bean Reactor output(Environment env) { Reactors.reactor().env(env) .dispatcher(RING_BUFFER).get() } }


Reactor — Spring

!116

@Configuration @EnableReactor class ReactorConfiguration { !

@Bean Reactor input(Environment env) { Reactors.reactor().env(env) .dispatcher(RING_BUFFER).get() } !

@Bean Reactor output(Environment env) { Reactors.reactor().env(env) .dispatcher(RING_BUFFER).get() } }

Setup Environment


Reactor — Spring

!117

@Component class SimpleHandler { !

@Autowired Reactor reactor !

@Selector('test.topic') void onTestTopic(String s) { // Handle data } }


Reactor — Spring

!117




Inject reactor


Reactor — Spring

!117




Inject reactor

Register consumer on @reactor


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

!118


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

!119


Reactor — Groovy

!120

@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

!120


Works with Groovy 2 CompileStatic


Reactor — Groovy

!120


Works with Groovy 2 CompileStaticCoerce String to $(string)


Reactor — Groovy

!120



Send data back usingreplyTo key header


Reactor — Groovy

!120




Coerce data arg toEvent.wrap(data)


Reactor — Groovy

!120





Notify & Listen for replies


Reactor — Groovy

!120





Notify & Listen for repliesStop listening for replies


Reactor — Groovy Promises and Streams

!121

def promise = Promises.task { longStuff(); 1 } get() !

def transformation = promise | { it + 1 } transformation.await() == 2 !

def deferredStream = Streams.defer().get() (deferredStream & { it > 2 }) << { send(it) } !

deferredStream << 1 << 2 << 3 << 4



!121





Build an async function



!121






Pipe promise with theclosure transformation



!121







Filter the stream withthe right hand closure

predicate



!121








predicate

Add callback after filter



!121








predicate

Add callback after filter

Send data


Reactor — Groovy Environment

!122


dispatcher('test') { type = DispatcherType.SYNCHRONOUS } } }.environment()



!122



Works with Groovy 2@CompileStatic



!122




Prepare an environmentbuilder



!122





which dispatcher to usewhen creating a reactor



!122






Build a standardDispatcher



!122






Build a standardDispatcherReturn a ready to

use Environment



!123

GroovyEnvironment.create { reactor('test1') { stream('test') { consume { ev-‐> log.info ev.data } } on('test') { reply it } } }



!123


Build a named Reactor



!123



Intercept the datastream coming by the

selector $(‘test’)



!123





Stream builder



!123





Stream builder

Attach inline consumers


Reactor — Extensive Awesomeness

● TCP Client/Server, with a Netty 4 implementation

● Buffer tools

● Sequencer support, for event ordering

● Work Queue support with OoB Java Chronicle implementation

● Log Appender

!124


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

!125


Reactor — Roadmap

● 1.1 discussions − HTTP helpers

− Improved RingBuffer API for multithreaded consumers

(slow consumers)

− More Groovy Love: Buffer, TCP, Processor, Time,

!126


Reactor — Uber Community Contribs

● Meltdown: A Clojure binding by @michaelklishin & @ifesdjeen

− https://github.com/clojurewerkz/meltdown

!127

https://github.com/clojurewerkz/meltdown


Reactor — Uber Community Contribs

!

● 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

!128

http://nitschinger.at/Using-the-Reactor-Processor-for-High-Performance-TCP

Grails

Part 3


Grails — The Age of Asynchronous

Fact #1: – HTTP request thread is critical path – Do the barely necessary for fast rendering – If it’s long*, do it in a separate thread

!131



Fact #2: – Creating new Threads needs caution – Context switching hurts performances – Concurrent programming is tricky*

!132



Fact #3: – Burden on your application is never constant – Scaling Up is a good start… – …And Scaling Out is only next

!133



So I have to use background threads ? But using them might lead to issues and headaches ? And what if I really need to scale out ?

!134


Grails — Reactive Programming Recap

• Adding a level of indirection : Driving your application with Events

• Laziness is key • Scale up/out by tweaking dispatching

!135


Grails — The Big Picture

!136

Events Bus

Service Consumer

Service Consumer

Service Consumer

Service Consumer

Service Consumer

Application



!136

Events Bus

Publish/Subscribe

Service Consumer

Service Consumer

Service Consumer

Service Consumer

Service Consumer

Application



!137

Events Bus

Publish/Subscribe

App

App

App

App

App

Cloud

@glaforge — @smaldini / #DV13-rtweb@glaforge — @smaldini / #DV13-rtweb !138

Introducing GRAILS-‐EVENTS plugin

BOOM!

worse slide ever™


Grails — Origins : Platform-Core plugin

• An initiative to provide modern tools for grails development

!

• Among them: the Events API

• An abstraction used in a few Grails applications today to decouple logic from producers

!

• grails-events can be considered as Platform Core Events API 2.0

!139


Grails — Why a new plugin ?

• New features. And quite a few. – Streaming data, Selectors, Queue

!

• Based on a new solid foundation – Reactor – Where Platform-core Events best ideas have leaked

!

• Semantic changes – But relatively straightforward migration path

!140


Grails — Why a new plugin ?

• Lightweight, only focused on events

!

• Ready to be embedded in a future Grails version

• Complete the asynchronous story

• Could enable runtime plugin deployment

!141


Grails — So what Grails Events is about

• Grails Apps and Plugins can use Events to:

– Listen for plugins/app events

– Start simple with in-memory eventing (#uberfastdata)

– Do Asynchronous calls (default)

– Increase in flexibility if required

!142


Grails — Installing Grails Events

• It’s a binary plugin (!) • Requires Grails 2.2+

!143

repositories { //... mavenRepo "http://repo.springsource.org/libs-‐snapshot" mavenRepo "http://repo.grails.org/grails/libs-‐snapshots-‐local/" } !

dependencies { compile 'org.grails.plugins:events:1.0.0.BUILD-‐SNAPSHOT' }


Grails — Semantics: Consumer

• A Consumer:

– Accepts an Event

– Is registered in a Service or Events artifact, or by calling on()

– Can be thread safe

• Depending on the dispatcher type

• Assuming the consumer is not registered more than once

!144


Grails — Semantics: Selector

• A Selector:

– Matches an event key

– Is paired with a consumer during its registration

– Any bean method can be transformed into consumer with @Selector

!145


Grails — Semantics: Reactor

• A Reactor: – Is a dedicated Consumer Registry – Has an assigned Dispatcher – Uses a specific Event Router

!

• Usually, if the Dispatcher doesn’t need to be adapted, reuse the default reactor grailsReactor

!146


Grails — Pattern Examples : Event Driven CQRS

!147

GORM

http://martinfowler.com/bliki/CQRS.html

DBPostProcessingService

SaveService



!147

GORM



SaveService

Consume afterInsert events



!147

GORM



SaveService


Save a GORM entity



!147

GORM



SaveService


Save a GORM entity

Insert Record



!147

GORM



SaveService


Save a GORM entity

Insert RecordTrigger afterInsert

event


Grails — Pattern Examples : Modular Architecture

!148

Notification Plugin

RequestServiceMain Application

NotificationService



!148

Notification Plugin


NotificationService

Trigger ‘request’ event



!148

Notification Plugin


NotificationService


Create a decoupled module



!148

Notification Plugin


NotificationService


Create a decoupled module Consume ‘request’ events



!148

Notification Plugin


NotificationService


Create a decoupled module Consume ‘request’ events

Core application untouched


Grails — Pattern Examples : Background Processing

!149

REST service

Grails Controller HTTP Request

Request Service



!149

REST service


Return immediately

Request Service



!149

REST service


Return immediately

Request Service

Trigger ‘request’event (async)



!149

REST service


Return immediately

Request Service

Trigger ‘request’event (async)

Long REST call


Grails — Sending Events (grails-platform-core)

!150

def user = new User(params).save() !

event('mailRegistration', user) //event('mailRegistration', user).waitFor() //event topic:'mailRegistration', data:user //event topic:'mailRegistration', data:user, fork:false render(view:'sendingRegistrationMail')


Grails — Sending Events (grails-events)

!151


event('mailRegistration', user) event('mailRegistration', user) { if(it == ‘end') { cancel() } } !

// event key: 'mailRegistration', data: user !

render(view: 'sendingRegistrationMail')



!151





Non blocking call totrigger app consumers



!151






Do things on each reply



!151






Do things on each reply

Map notation


Grails — Consuming Events (grails-platform-core)

!152

class UserService{ @grails.events.Listener def mailRegistration(User user) { sendMail { to user.mail subject "Confirmation" html g.render(template:"userMailConfirmation") } } ! @grails.events.Listener(topic= "mailRegistration") def mailRegistration2(org.grails.plugin.platform.events.EventMessage msg) { sendMail{ to msg.data.mail subject "Confirmation" html g.render(template: "userMailConfirmation") } } }


class UserService{ @reactor.spring.annotation.Selector def mailRegistration(User user){ sendMail{ to user.mail subject "Confirmation" html g.render(template: "userMailConfirmation") } } ! @reactor.spring.annotation.Selector("mailRegistration") def mailRegistration2(reactor.event.Event msg){ sendMail{ to msg.data.mail subject "Confirmation" html g.render(template:"userMailConfirmation") } } }

Grails — Consuming Events (grails-events)

!153




!153

Consume onSelector(method name)




!153


Consume on thisspecific topic




!153


Consume on thisspecific topic

Event typed signatureto inspect enveloppe

(‘headers…)


includes = ['default'] !doWithReactor = { reactor(EventsApi.GRAILS_REACTOR) { on('someTopic') { reply 'test' } } reactor(‘someGormReactor') { dispatcher = new SynchronousDispatcher() ext 'gorm', true ! stream { consume { log.info "Some gorm event is flowing with data $it.data" }.when(Throwable) { log.error "Ow snap!", it } } } }

Grails — A new Artifact conf/XxxxEvents

!154




!154

Merge with DefaultsEvents




!154


Build a GroovyEnvironment




!154



Reactor Groovy Builders




!154



Reactor Groovy Builders

Grails extension: accept GORM events


Grails — Reactor awesomeness : Selectors

• Listen for arbitrary keys • import static reactor.event.selector.Selectors.*

!155

on(T(SpecificClassType)) { reply it } !

event(new SpecificClassType(), 'data') !

!

on(uri(‘/some/{captureIt}')) { reply it.headers.captureIt } !

event('/some/hourray', 'data')




!155



!



Listen for SpecificClassType




!155



!



Listen for an URI





!155



!



Listen for an URI


Send using right key type




!155



!



Listen for an URI


Send using right key type

Send using matching URI


Grails — Reactor awesomeness : Stream API

• Reactive Extensions programming style • Avoid callback hell

!156

withStream { event(key: 'test', data: 1) }.when(Exception, { log.info "exception:$it" }).map { callExternalService(it) }.consume('clientKey', reactor('browser'))




!156


Build a Stream to capture any reply




!156


If a consumer fails





!156


If a consumer fails


$(‘test’) consumers may reply




!156


If a consumer fails



Transform result




!156


If a consumer fails



Transform result

Reroute to key ‘clientKey’on Reactor ‘browser’


Grails — Reactor awesomeness: Promise API

• Grails 2.3 Promises become a Reactor Promises • Benefits from Dispatcher overriding • Powerful once Combined with Consumers

!157

dispatcher(ReactorPromise.PromiseDispatcher) { type = DispatcherType.RingBuffer backlog = 512 }


Grails — Reactor awesomeness: Promise API

• Grails 2.3 Promises become a Reactor Promises • Benefits from Dispatcher overriding • Powerful once Combined with Consumers

!157

dispatcher(ReactorPromise.PromiseDispatcher) { type = DispatcherType.RingBuffer backlog = 512 }

task { def res = longProcessing() render res }


Grails — Reactor awesomeness : Routing

• During event dispatching, consumers list is selected • Publish Subscribe is the default • Possible to assign different routing strategy

!158

reactor('test1') { routingStrategy 'round-‐robin' on('test') { reply '1' } on('test') { reply '2' } }


Grails — Reactor awesomeness : Routing

• During event dispatching, consumers list is selected • Publish Subscribe is the default • Possible to assign different routing strategy

!158

reactor('test1') { routingStrategy 'round-‐robin' on('test') { reply '1' } on('test') { reply '2' } }

Will reply 1, 2, 1, 2, 1, 2…


Grails — Extensibility

!

• Main extension points: – Dispatcher, Selector, Registry, EventRouter, Consumer

!

• Metadata in Reactor Events DSL: – ext(‘someExtension’, [ ‘doStuff ’: true ])

!159


Grails — GORM events

• GORM is now an extension – Using ext(‘gorm’, true) on any candidate reactor – Applicable Selectors: simple topic form (beforeInsert...) – A boolean reply is evaluated as a cancel directive

!160

reactor('someGormReactor'){ dispatcher = new SynchronousDispatcher() ext 'gorm', true }


Grails — GORM events

• GORM is now an extension – Using ext(‘gorm’, true) on any candidate reactor – Applicable Selectors: simple topic form (beforeInsert...) – A boolean reply is evaluated as a cancel directive

!160

reactor('someGormReactor'){ dispatcher = new SynchronousDispatcher() ext 'gorm', true } @Selector(reactor = 'someGormReactor')

@ReplyTo boolean beforeValidate(Book b){ false }

@glaforge — @smaldini / #DV13-rtweb@glaforge — @smaldini / #DV13-rtweb !161

GRAILS-‐EVENTS-‐PUSH pluginEventing over HTTP!


Grails — Pattern Examples : “Realtime” web

!162

Browser

ResponseService

Grails Controller RequestService



!162

Browser

ResponseService

Grails Controller

Return immediately

RequestService



!162

Browser

ResponseService

Grails Controller

Return immediately

RequestService

Trigger async event



!162

Browser

ResponseService

Grails Controller

Return immediately

RequestService

Trigger async event

Reply a new event



!162

Browser

ResponseService

Grails Controller

Return immediately

RequestService

Trigger async event

Reply a new eventPush reply to browser: Websocket, SSE, long-polling…


Grails — An elegant solution to browser push

• Powered by Atmosphere 2

• Automatically picks an adapted protocol:

– WebSockets, ServerSideEvent, Streaming, Polling…

• Consumer bridges for server-to-client push

• Reactor bridge for client-to-server push

• Javascript library

!163


Grails — Installing Grails Events Push

1. Install Grails Events plugin 2. Install Grails Events Push plugin

!164

grails.servlet.version = "3.0" grails.tomcat.nio = true !grails.project.dependency.resolution = { repositories { //... mavenRepo "https://oss.sonatype.org/content/repositories/snapshots" } dependencies { //... compile 'org.grails.plugins:events:1.0.0.BUILD-‐SNAPSHOT' } plugins { //... runtime ":jquery:1.10.2" runtime ":events-‐push:1.0.0.BUILD-‐SNAPSHOT" } }


Grails — Installing Grails Events Push

1. Install Grails Events plugin 2. Install Grails Events Push plugin

!164

grails.servlet.version = "3.0" grails.tomcat.nio = true !grails.project.dependency.resolution = { repositories { //... mavenRepo "https://oss.sonatype.org/content/repositories/snapshots" } dependencies { //... compile 'org.grails.plugins:events:1.0.0.BUILD-‐SNAPSHOT' } plugins { //... runtime ":jquery:1.10.2" runtime ":events-‐push:1.0.0.BUILD-‐SNAPSHOT" } }

Use a “long-connection” friendlytomcat configuration


Grails — grails-events-push Lifecycle 1 - Handshake

!165

Browser EventsPushHandler


Grails — grails-events-push Lifecycle 1 - Handshake

!165

Browser EventsPushHandler

Adapt Protocol and Opennew persistent connection


Grails — grails-events-push Lifecycle 2 - Register

!166

Browser Reactor(s)



!166

Browser Reactor(s)

Bridge a Client Consumer with aremote Reactor Consumer



!166

Browser Reactor(s)

Bridge a Client Consumer with aremote Reactor Consumer

Consumer registered on all Reactor with‘browser’ extension enabled


Grails — grails-events-push Lifecycle 3 - Notify

!167

Browser ‘browser’ Reactor RequestService



!167

Browser ‘browser’ Reactor

Notify any key

RequestService



!167

Browser ‘browser’ Reactor

Notify any key

RequestService

RequestService consumes on matchingSelector within the ‘browser’ Reactor


Grails — grails-events-push Lifecycle 4 - Consume

!168

Browser Reactor(s) ResponseService



!168

Browser Reactor(s)

Push event (WS, SSE…)

ResponseService



!168

Browser Reactor(s)

Push event (WS, SSE…)

ResponseService

Notify ‘browser’ enabledReactor and match key


Grails — Generating Simple Browsers bridges

!169

includes = 'push' !doWithReactor = { reactor('browser') { ext 'browser', [ 'control', 'move', 'fire', 'leave' ] } reactor(‘grailsReactor') { ext 'browser', ['sleepBrowser'] ! stream(‘sleepBrowser') { filter { it.data == 'no' } } } }



!169


Bridge browser to these reactorconsumers $(‘control),…



!169



Conventional name tooverride ‘browser’ reactor



!169




Bridge browser to this reactorconsumer $(‘sleepBrowser)



!169




Bridge browser to this reactorconsumer $(‘sleepBrowser)

Prevent data ‘no’ to bedispatched to browser bridges


Grails — React on server side events

!170



!170

Inject grailsEvents.js (requires resources plugin)



!170


Create a connectionbetween the browser and

the current Grails app



!170


Create a connectionbetween the browser and

the current Grails app

Listen for $(‘afterInsert’) events


Grails — Generating Advanced Browsers bridges

!171

includes = ['push'] !doWithReactor = { reactor(‘grailsReactor') { ext 'gorm', true ext 'browser', [ 'test': true, 'afterInsert': [ browserFilter: {m, r -‐> true } ], (R("sampleBro-‐.*")) : true, ] } reactor(EventsPushConstants.FROM_BROWSERS) { ext 'browser', [R("sampleBro-‐.*")] } }



!171


Include PushEvents (configure areactor for events from Browsers)



!171



Listen on GORM events



!171




Extension to bridgeBrowsers consumers to

Server-side pair



!171





Server-side pair

Override “From Browsers” reactorand bridge consumers



!171





Server-side pair

Override “From Browsers” reactorand bridge consumersEvents are only routed, from

Browsers to bridged Browsers


Grails — The Bad Stuff

• events-si : Events API on top of Spring Integration – Not here (just) yet

!

• events-vertx : Abandoned experiment – Working around Distributed Reactor

!

• Stream DSL could be optimized – Reducing the number of objects

!172


Grails — Roadmap

• events: – Document, especially for Migration from Platform Core – Stick with latest awesome features from Reactor • Still Many API to expose: Processors, Buffer, TCP, Queues,

Sequencer… !

• events-push -> events-atmosphere : – Add support for replyTo – extract to standalone module : reactor-atmosphere

!173


Grails — Roadmap

• events-sockjs: – Involves Reactor work here

!

• events-si: – Supports new events plugin

!

• events-xx: – The plugin where you are the hero

!174

Summary

Part 4


Groovy, Reactor, Grails and the realtime web

• Embrace modern reactive architectures with Groovy, Reactor and Grails!

• Groovy is a versatile language, that enables development of concise and functional oriented applications

• Reactor fuels your asynchronous and reactive applications with its ultra fast dispatching engine and non-blocking model.

• Grails supports your today's and tomorrow's web app design, tooled with the right plugins you are prepared for responsive and interactive applications

!177

Groovy reactor grails realtime web devoxx 2013

Technology

Transcript of Groovy reactor grails realtime web devoxx 2013