Design Patterns and Best Practices in Java: A comprehensive guide to building smart and reusable code in Java

✍ Scribed by Kamalmeet Singh; Adrian Ianculescu; Lucian-Paul Torje

• Publisher: Packt Publishing Ltd
• Year: 2018
• Tongue: English
• Leaves: 272
• Category: Library

✦ Synopsis

Create various design patterns to master the art of solving problems using Java

Key Features

• This book demonstrates the shift from OOP to functional programming and covers reactive and functional patterns in a clear and step-by-step manner
• All the design patterns come with a practical use case as part of the explanation, which will improve your productivity
• Tackle all kinds of performance-related issues and streamline your development

Book Description

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.

What you will learn

• Understand the OOP and FP paradigms
• Explore the traditional Java design patterns
• Get to know the new functional features of Java
• See how design patterns are changed and affected by the new features
• Discover what reactive programming is and why is it the natural augmentation of FP
• Work with reactive design patterns and find the best ways to solve common problems using them
• See the latest trends in architecture and the shift from MVC to serverless applications
• Use best practices when working with the new features

Who this book is for

This book is for those who are familiar with Java development and want to be in the driver’s seat when it comes to modern development techniques. Basic OOP Java programming experience and elementary familiarity with Java is expected.

✦ Table of Contents

Title Page
Copyright and Credits
Packt Upsell
Contributors
Table of Contents
Preface
Chapter 1: From Object-Oriented to Functional Programming
Java – an introduction
Java programming paradigms
Imperative programming
Real-life imperative example
Object-oriented paradigm
Objects and classes
Encapsulation
Abstraction
Inheritance
Polymorphism
Declarative programming
Functional programming
Working with collections versus working with streams
An introduction to Unified Modeling Language
Class relations
Generalization
Realization
Dependency
Association
Aggregation
Composition
Design patterns and principles
Single responsibility principle
Open/closed principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency inversion principle
Summary
Chapter 2: Creational Patterns
Singleton pattern
Synchronized singletons
Synchronized singleton with double-checked locking mechanism
Lock-free thread-safe singleton
Early and lazy loading
The factory pattern
Simple factory pattern
Static factory
Simple factory with class registration using reflection
Simple factory with class registration using Product.newInstance
Factory method pattern
Anonymous concrete factory
Abstract factory
Simple factory versus factory method versus abstract factory
Builder pattern
Car builder example
Simplified builder pattern
Anonymous builders with method chaining
Prototype pattern
Shallow clone versus deep clone
Object pool pattern
Summary
Chapter 3: Behavioral Patterns
The chain-of-responsibility pattern
Intent
Implementation
Applicability and examples
The command pattern
Intent
Implementation
Applicability and examples
The interpreter pattern
Intent
Implementation
Applicability and examples
The iterator pattern
Intent
Implementation
Applicability and examples
The observer pattern
Intent
Implementation
The mediator pattern
Intent
Implementation
Applicability and examples
The memento pattern
Intent
Implementation
Applicability
The state pattern
The strategy pattern
Intent
Implementation
The template method pattern
Intent
Implementation
The null object pattern
Implementation
The visitor pattern
Intent
Implementation
Summary
Chapter 4: Structural Patterns
Adapter pattern
Intent
Implementation
Examples
Proxy pattern
Intent
Implementation
Examples
Decorator pattern
Intent
Implementation
Examples
Bridge pattern
Intent
Implementation
Examples
Composite pattern
Intent
Implementation
Examples
Façade pattern
Intent
Implementation
Examples
Flyweight pattern
Intent
Implementation
Examples
Summary
Chapter 5: Functional Patterns
Introducing functional programming
Lambda expressions
Pure functions
Referential transparency
First-class functions
Higher-order functions
Composition
Currying
Closure
Immutability
Functors
Applicatives
Monads
Introducing functional programming in Java
Lambda expressions
Streams
Stream creator operations
Stream intermediate operations
Stream terminal operations
Re-implementing OOP design patterns
Singleton
Builder
Adapter
Decorator
Chain of responsibility
Command
Interpreter
Iterator
Observer
Strategy
Template method
Functional design patterns
MapReduce
Intent
Examples
Loan pattern
Intent
Examples
Tail call optimization
Intent
Examples
Memoization
Intent
Examples
The execute around method
Intent
Examples
Summary
Chapter 6: Let's Get Reactive
What is reactive programming?
Introduction to RxJava
Installing the RxJava framework
Maven installation
JShell installation
Observables, Flowables, Observers, and Subscriptions
Creating Observables
The create operator
The defer operator
The empty operator
The from operator
The interval operator
The timer operator
The range operator
The repeat operator
Transforming Observables
The subscribe operator
The buffer operator
The flatMap operator
The groupBy operator
The map operator
The scan operator
The window operator
Filtering Observables
The debounce operator
The distinct operator
The elementAt operator
The filter operator
The first/last operator
The sample operator
The skip operator
The take operator
Combining Observables
The combine operator
The join operator
The merge operator
The zip operator
Error handling
The catch operator
The do operator
The using operator
The retry operator
Schedulers
Subjects
Example project
Summary
Chapter 7: Reactive Design Patterns
Patterns for responsiveness
Request-response pattern
Asynchronous-communication pattern
Caching pattern
Fan-out and quickest-reply pattern
Fail-fast pattern
Patterns for resilience
The circuit-breaker pattern
Failure-handling pattern
Bounded-queue pattern
Monitoring patterns
Bulkhead pattern
Patterns for elasticity
Single responsibility pattern
Stateless-services pattern
Autoscaling pattern
Self-containment pattern
Patterns for message-driven implementation
Event-driven communication pattern
Publisher-subscriber pattern
Idempotency pattern
Summary
Chapter 8: Trends in Application Architecture
What is application architecture?
Layered architecture
Layered architecture with an example
Tiers versus layers
What does layered architecture guarantee?
What are the challenges with layered architecture?
Model View Controller architecture
MVC architecture with an example
A more contemporary MVC implementation
What does MVC architecture guarantee?
What are the challenges with MVC architecture?
Service-oriented architecture
Service-oriented architecture with an example
Web services
SOAP versus REST
Enterprise service bus
What does service-oriented architecture guarantee?
What are the challenges with service-oriented architecture?
Microservices-based Architecture
Microservice architecture with an example
Communicating among services
What does microservices-based architecture guarantee?
What are challenges with microservices-based architecture?
Serverless architecture
Serverless architecture with an example
Independence from infrastructure planning
What does serverless architecture guarantee?
What are the challenges with serverless architecture?
Summary
Chapter 9: Best Practices in Java
A brief history of Java
Features of Java 5
Features of Java 8
Currently supported versions of Java
Best practices and new features of Java 9
Java platform module system
JShell
Private methods in interfaces
Enhancements in streams
Creating immutable collections
Method addition in arrays
Additions to the Optional class
New HTTP client
Some more additions to Java 9
Best practices and new features of Java 10
Local variable type inference
copyOf method for collections
Parallelization of full garbage collection
Some more additions to Java 10
What should be expected in Java 11?
Summary
Other Books You May Enjoy
Index