Book Overview & Buying
Table Of Contents
Feedback & Rating

Design Patterns and Best Practices in Java

By : Singh, Puri, Ianculescu, Torje

3.5 (4)

Buy this Book

Design Patterns and Best Practices in Java

3.5 (4)

By: Singh, Puri, Ianculescu, Torje

Buy this Book

Overview of this book

Having a knowledge of design patterns enables you, as a developer, to improve your code base, promote code reuse, and make the architecture more robust. As languages evolve, new features take time to fully understand before they are adopted en masse. The mission of this book is to ease the adoption of the latest trends and provide good practices for programmers. We focus on showing you the practical aspects of smarter coding in Java. We'll start off by going over object-oriented (OOP) and functional programming (FP) paradigms, moving on to describe the most frequently used design patterns in their classical format and explain how Java’s functional programming features are changing them. You will learn to enhance implementations by mixing OOP and FP, and finally get to know about the reactive programming model, where FP and OOP are used in conjunction with a view to writing better code. Gradually, the book will show you the latest trends in architecture, moving from MVC to microservices and serverless architecture. We will finish off by highlighting the new Java features and best practices. 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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

From Object-Oriented to Functional Programming

Java – an introduction

Java programming paradigms

Imperative programming

Object-oriented paradigm

Declarative programming

Functional programming

An introduction to Unified Modeling Language

Design patterns and principles

Summary

Creational Patterns

Singleton pattern

The factory pattern

Builder pattern

Prototype pattern

Object pool pattern

Summary

Behavioral Patterns

The chain-of-responsibility pattern

The command pattern

The interpreter pattern

The iterator pattern

The observer pattern

The mediator pattern

The memento pattern

The state pattern

The strategy pattern

The template method pattern

The null object pattern

The visitor pattern

Summary

Structural Patterns

Adapter pattern

Proxy pattern

Decorator pattern

Bridge pattern

Composite pattern

Façade pattern

Flyweight pattern

Summary

Functional Patterns

Introducing functional programming

Introducing functional programming in Java

Re-implementing OOP design patterns

Functional design patterns

Summary

Let's Get Reactive

What is reactive programming?

Introduction to RxJava

Installing the RxJava framework

Observables, Flowables, Observers, and Subscriptions

Creating Observables

Transforming Observables

Filtering Observables

Combining Observables

Error handling

Schedulers

Subjects

Example project

Summary

Reactive Design Patterns

Patterns for responsiveness

Patterns for resilience

Patterns for elasticity

Patterns for message-driven implementation

Summary

Trends in Application Architecture

What is application architecture?

Layered architecture

Model View Controller architecture

Service-oriented architecture

Microservices-based Architecture

Serverless architecture

Summary

Best Practices in Java

A brief history of Java

Best practices and new features of Java 9

Best practices and new features of Java 10

What should be expected in Java 11?

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

3.5 (4)

5 star

50%

4 star

3 star

2 star

50%

1 star

Introduction to RxJava

RxJava is an implementation of reactive extension (a library for composing asynchronous and event-based programs by using observable sequences) ported from the Microsoft .NET world. In 2012, Netflix realized that they needed a paradigm shift since their architecture could not cope with their huge customer base, so they decided to go reactive by bringing the power of the reactive extension to the JVM world; this is how RxJava was born. There are other JVM implementations besides RxJava, such as RxAndroid, RxJavaFX, RxKotlin, and RxScale. This approach gave them the desired boost, and by making it publicly available, it also offered us the opportunity to use it.

RxJava JAR is licensed under the Apache Software License, version 2.0, and available in the central maven repository.

There are a couple of external libraries that make use of RxJava: