Book Image

Hands-On Design Patterns with Kotlin

By : Alexey Soshin
Book Image

Hands-On Design Patterns with Kotlin

By: Alexey Soshin

Overview of this book

Design patterns enable you as a developer to speed up the development process by providing you with proven development paradigms. Reusing design patterns helps prevent complex issues that can cause major problems, improves your code base, promotes code reuse, and makes an architecture more robust. The mission of this book is to ease the adoption of design patterns in Kotlin and provide good practices for programmers. The book begins by showing you the practical aspects of smarter coding in Kotlin, explaining the basic Kotlin syntax and the impact of design patterns. From there, the book provides an in-depth explanation of the classical design patterns of creational, structural, and behavioral families, before heading into functional programming. It then takes you through reactive and concurrent patterns, teaching you about using streams, threads, and coroutines to write better code along the way By the end of the book, you will be able to efficiently address common problems faced while developing applications and be comfortable working on scalable and maintainable projects of any size.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Design Patterns with Kotlin
Alexey Soshin
Jun, 2018 | 310 pages
Small book image
Functional Kotlin
Rivu Chakraborty | Mario Arias
Feb, 2018 | 350 pages
Small book image
Hands-On Object-Oriented Programming with Kotlin
Igor Kucherenko | Abid Khan
Oct, 2018 | 370 pages
Small book image
Android Development with Kotlin
Igor Wojda | Marcin Moskala
Aug, 2017 | 440 pages
Table of Contents (13 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Getting Started with Kotlin
Getting Started with Kotlin
Basic language syntax and features
Introduction to design patterns
Summary
2
Working with Creational Patterns
Working with Creational Patterns
Singleton
Factory Method
Abstract Factory
Builder
Prototype
Summary
3
Understanding Structural Patterns
Understanding Structural Patterns
Decorator
Adapter
Bridge
Composite
Facade
Flyweight
Proxy
Summary
4
Getting Familiar with Behavioral Patterns
Getting Familiar with Behavioral Patterns
Strategy
Iterator
State
Command
Chain of responsibility
Interpreter
Mediator
Memento
Visitor
Template method
Observer
Summary
5
Functional Programming
Functional Programming
Why functional programming?
Immutability
Functions as values
Expressions, not statements
Recursion
Summary
6
Streaming Your Data
Streaming Your Data
The it notation
The map() function
Filter family
Find family
Drop family
Sort family
ForEach
Join family
Fold/Reduce
Flat family
Slice
Chunked
Zip/Unzip
Streams are lazy, collections are not
Sequences
Summary
7
Staying Reactive
Staying Reactive
Reactive principles
Reactive extension
Summary
8
Threads and Coroutines
Threads and Coroutines
Threads
Coroutines
Summary
9
Designed for Concurrency
Designed for Concurrency
Active Object
Deferred value
Barrier
Scheduler
Pipelines
The fan-out design pattern
The fan-in design pattern
Buffered channels
Unbiased select
Mutexes
Selecting on close
Sidekick channel
Deferred channel
Summary
10
Idioms and Anti-Patterns
Idioms and Anti-Patterns
Let
Apply
Also
Run
With
Instance checks
Try-with-resources
Inline functions
Reified
Constants
Constructor overload
Dealing with nulls
Explicit async
Validation
Sealed, not enumerated
More companions
Scala functions
Summary
11
Reactive Microservices with Kotlin
Reactive Microservices with Kotlin
Getting started with Vert.x
Handling requests
Testing
Working with databases
EventBus
Summary
12
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Reactive extension

The rest of this chapter will be dedicated to the specific implementation of reactive principles in Kotlin. The predominant library in this field is RxJava. Since Kotlin is fully interoperable with Java libraries, RxKotlin is only a thin wrapper over the original RxJava. Hence, we'll discuss it as if these are one and the same library, and highlight the differences, if any.

As soon as we start talking about RxJava, you'll recognize it's built upon the Observer design pattern we discussed in Chapter 4, Getting Familiar with Behavioral Patterns.

We'll start by adding the following dependency to our Gradle project:

compile "io.reactivex.rxjava2:rxjava:2.1.14"

Currently, this is the latest version of RxJava2, but when you read this chapter, there will probably ba a more recent version already. Feel free to use it.

You may remember...

Previous Section
End of Section 3
Next Section