Appendix A: Java 10 and 11

Java 10 was released on March 20, 2018. The main substantial update of Java 10 was Local Variable Type Inference (var). It also included enhancements for garbage collection and compilation, but that will not affect how we write our code.

Local Variable Types

Although “var” is not a new keyword, it is a context-sensitive type and represents a huge leap forward for Java developers . It allows you to substitute a type declaration with “var” whenever the type can be clearly inferred from context by the Java compiler.

For example, given a test on our “doParallelSquares” method, we can rewrite it for Java 10+ in the following way:

@Test

public void testDoParallelSquares() {

  var result = demo.doParallelSquares()

   .stream().sorted().collect(Collectors.toList());

  assertArrayEquals(squares.toArray(),

        result.toArray());

}

Here the type of result is inferred from the right side of the assignment (it happens to be List<Integer>).

We can use “var” whenever the type is clear from the right side of the assignment, without loss of meaning to human readers . For example, the following is an initialization of a list:

var list = new ArrayList();

Keep in mind that the type of list will be a raw ArrayList; however, in some cases, that might be fine for our purposes.

With Reactive Streams , it can be helpful to use “var” to simplify code in many cases without losing anything. For example:

var monoError = Mono.error(

        new RuntimeException("error")); //1

var foo = Mono.just("foo"); //2

var flux = Flux.just(1, 4, 9); //3

var flux = Flux.just(1);

var stringFlux = flux.map(i -> "string " + i); //4

1. 1.

   Create a Mono that wraps an exception.

    
2. 2.

   Create a Mono wrapping a single value.

    
3. 3.

   Declare a Flux with initial values.

    
4. 4.

   Declare an intermediate step.

    

Especially in testing, var can useful for simplifying Java code.

var publisher = TestPublisher.create(); //1

var stringFlux = publisher.flux(); //2

1. 1.

   Create a TestPublisher from Reactor.

    
2. 2.

   Convert it into a Flux .

    

Lambda Expression Local Variable Types

In Java 11 “var” can also be used in lambda expression parameters for consistency. For example, the following code

stringFlux.subscribe(next -> list.add(next), ex -> ex.printStackTrace());

could be changed to the following in Java 11:

stringFlux.subscribe((var next) -> list.add(next),

        (var ex) -> ex.printStackTrace());

Although a bit longer in syntax, this adds better consistency to the Java language and allows for things like adding annotations to those parameters without specifying a type. For example:

stringFlux.subscribe(

        (@NonNull var next) -> list.add(next),

        (@NonNull var ex) -> ex.printStackTrace());

We use Java 10+ local variable types throughout the book to simplify some code examples .

Index

A

ActorMaterializer

Akka framework

Akka HTTP

ByteString

JSON

multipart

SSE

WebSocket

Akka Streams

ActorMaterializer

backpressure

BroadcastHub

flatMapConcat

flatMapMerge

Flow, Graph, Source, and Sink

Gradle builds

interoperation

Java-specific API

mapConcat

Maven build

MergeHub

messages

PartitionHub

RxJava and Reactor

Source and Sink

testing

TestKit

TestSink

TestSource

Akka Streams, Akka HTTP

ActorSystem

build.gradle

Routes

SBT

testing

WebApp

Android and RxJava

Android SDK

app, module name

login activity

RxAndroid

RxAndroidTest

testing

version

AndroidSchedulers

Android SDK

Any/All returns

Automated testing

B

Backpressure

backpressure()

bridge.onBackpressureBuffer(256)

dropBuffer()

dropNew()

dropTail()

fail()

hot Observables

onBackpressureBuffer()

onBackpressureBuffer(maxSize, BufferOverflowStrategy)

onBackpressureDrop()

onBackpressureDrop(Consumer)

onBackpressureError()

onBackpressureLatest()

strategies

toFlowable(BackpressureStrategy.ERROR)

toFlowable(strategy)

BroadcastHub

Buffer

C

ChatServer

Cold Observable

CompletableFuture

CompletionStage

ConcatMap

Concurrency

actors, Akka framework

GPars

Java future interface

asynchronous computation

asynchronous versions

CompletableFuture

CompletionStage

drawbacks

Reactive Streams

STM

synchronize

Controllers

CourseRepository

D, E

Debounce

Delay

Domain model

F

Filter

FlatMap

G

GetMapping annotation

GPars

Gradle bootRepackage

Gradle bootRun

Gradle plugin

MongoDB

PostgreSQ

Project Lombok

reactor-test

Spring Boot

spring-boot-starter-test

WebFlux

Gzip and Deflate Content-Encoding

H, I

Handling errors, RxJava

TestObserver

TestScheduler

TestSubscriber

Hot Observable

HTTP/2

J, K

Java 2

Java 10

lambda expression

variable types

Java Development Kit (JDK)

java.util.concurrent.Flow class

Java virtual machine (JVM)

JSON

JSON map

L

Lambda expression

Lombok annotations

M, N, O

Map

Materializer

MergeHub and Publisher

MongoDB

P, Q

Parallel computing

PartitionHub

PostgreSQL

Processor<T,R>

Publisher<T>

Pull events

R

ReactiveMongoRepository

Reactive Streams

Reactor

backpressure ( see Backpressure)

context

Flux<T> and Mono<T>

creation

doOnError(Consumer<? super Throwable>)

generate, create, or push methods

handling errors

“hello”

justOrEmpty(Optional)

justOrEmpty(T)

MessageListener

onErrorMap(Function)

onErrorResume(Function)

onErrorReturn(T)

org.reactivestreams.Publisher

Schedulers.parallel()

Gradle builds

pull events

Schedulers

Spring Data

Spring Security

testing

automated

StepVerifier

TestPublisher

uses

readLineSupplier method

Repository

RestController

RESTful API

RxAndroid

RxBinding

RxJava

backpressure ( see Backpressure)

“build.gradle” file

definition

flowable

parallel computing

Publishers

blockingSubscribe

“IO” Scheduler

readFile(File)

readLineSupplier method

Subscriber interface

write file

schedulers

RxLifecycle

S

Scala’s build tool (SBT)

Schedulers

generating squares

newSingle

reactor.core.scheduler package

Schedulers.elastic()

Schedulers.fromExecutor(Executor)

Schedulers.immediate()

Schedulers.newSingle()

Schedulers.parallel()

Schedulers.single()

Server-sent events (SSE)

Software transactional memory (STM)

Spring Boot

annotation

configuration

flatMap

Gradle-based project

Maven-based project

Spring Initializr

testing

WebFlux-based project

SpringBootApplication

StepVerifier

Streams

Subscription

synchronize keyword

T, U, V

Take While

Templates

TestObserver

TestPublisher

TestScheduler

TestSubscriber

Throttle First

W, X, Y, Z

Web Client

createHelloRoute method

getResourceAsStream

onmessage event handler

readAllBytes method

WebSocket

WebSocket Flow

ChatMessage

createWebsocketRoute method

FlowShape

GraphDSL

mapAsync

parseContent method

saveFlow

sinkInlet

storeChatMessages method

storeMessageFromContent method

WebSockets

greeter method

handleWebSocketMessages

isCheck

JavaPartialFunction

Window