Hands-On Design Patterns with Kotlin电子书

Title Page

Copyright and Credits

Hands-On Design Patterns with Kotlin

Dedication

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the author

About the reviewers

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

Getting Started with Kotlin

Basic language syntax and features

Multi-paradigm

Code structure

No semicolons

Naming conventions

Packages

Types

Type inference

val versus var

Comparison

Null safety

Declaring functions

Control flow

Using the if expression

Using the when expression

String interpolation

Classes and inheritance

Classes

Inheritance

Constructors

Properties

Data classes

More control flow – loops

The for loop

For-each loop

While loop

Extension functions

Introduction to design patterns

What are design patterns?

Design patterns in real life

Design process

Why use design patterns in Kotlin?

Summary

Working with Creational Patterns

Singleton

Factory Method

Factory

Static Factory Method

Advantages of the Static Factory Method

Caching

Subclassing

Static Factory Method in Kotlin

Companion object

Abstract Factory

Abstract Factory in action

Introduction to generics in Kotlin

Back to our bases

Making improvements

Builder

Composing an email

Collection types in Kotlin

Creating an email – first attempt

Creating an email – second attempt

Creating an email – the Kotlin way

Creating an email – the Kotlin way – second attempt

Prototype

Building your own PC

Starting from a prototype

Summary

Understanding Structural Patterns

Decorator

Enhancing a class

Operator overloading

Dude, where's my map?

The great combinator

Caveats

Adapter

Different adapters

Adapters in the real world

Caveats of using adapters

Bridge

Bridging changes

Type aliases

You're in the army now

Constants

A lethal weapon

Composite

Get together

The Squad

Varargs and secondary constructors

Counting bullets

Facade

Keep it simple

Flyweight

Being conservative

Saving memory

Proxy

A short detour into the RMI world

A replacement

Lazy delegation

Summary

Getting Familiar with Behavioral Patterns

Strategy

Fruit arsenal

Citizen function

Switching sides

Iterator

One, two... many

Running through the values

State

Fifty shades of State

State of the Nation

Command

Undoing commands

Chain of responsibility

Interpreter

We need to go deeper

A language of your own

Taking a break

Call suffix

Mediator

Trouble in the Jungle

The middleman

Flavors

Caveats

Memento

Remembrance

Visitor

Writing a crawler

Template method

Observer

Animal Choir

Summary

Functional Programming

Why functional programming?

Immutability

Tuples

Value mutation

Immutable collections

Functions as values

Higher-order functions

Pure functions

Currying

Memoization

Expressions, not statements

Pattern matching

Recursion

Summary

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

Staying Reactive

Reactive principles

Responsiveness

Resiliency

Elasticity

Message-driven

Reactive extension

Hot Observable

Multicast

Subject

ReplaySubject

BehaviorSubject

AsyncSubject

SerializedSubject

Flowables

Holding state

FlowableProcessor

Batching

Throttling

Summary

Threads and Coroutines

Threads

Thread safety

Threads are expensive

Coroutines

Starting coroutines

Jobs

Coroutine starvation

Coroutines under the hood

Fixing starvation

Waiting for a coroutine

Canceling a coroutine

Returning results

Setting timeouts

Parent jobs

Channels

Producers

Actors

Summary

Designed for Concurrency

Active Object

Testing

Deferred value

Barrier

CountDownLatch

Data class as Barrier

Scheduler

Understanding contexts

Pipelines

Establishing a pipeline

The fan-out design pattern

The fan-in design pattern

Managing workers

Buffered channels

Unbiased select

Mutexes

Selecting on close

Sidekick channel

Deferred channel

Summary

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

Reactive Microservices with Kotlin

Getting started with Vert.x

Routing

Handling requests

Verticles

Subrouting

Testing

Helper methods

Working with databases

Managing configuration

Managing the database

EventBus

Consumer

Producer

More testing

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think