Book Image

Design Patterns and Best Practices in Java

By : Kamalmeet Singh, Adrian Ianculescu, Lucian-Paul Torje
Book Image

Design Patterns and Best Practices in Java

By: Kamalmeet Singh, Adrian Ianculescu, Lucian-Paul Torje

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.

Related Content you might be interested in

Current Title:

Small book image
Design Patterns and Best Practices in Java
Kamalmeet Singh | Adrian Ianculescu | Lucian-Paul Torje
Jun, 2018 | 280 pages
Small book image
Practical Design Patterns for Java Developers
Miroslav Wengner
Feb, 2023 | 266 pages
Small book image
Java EE 8 Microservices
Mert Caliskan | Pavel Pscheidl | Ondrej Mihályi | Kamalmeet Singh
Dec, 2018 | 260 pages
Small book image
Hands-On Design Patterns with Java
Dr Edward Lavieri
Apr, 2019 | 360 pages
Table of Contents (15 chapters)
Title Page
Title Page
Packt Upsell
Packt Upsell
Contributors
Contributors
Preface
Preface
Free Chapter
1
From Object-Oriented to Functional Programming
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
2
Creational Patterns
Creational Patterns
Singleton pattern
The factory pattern
Builder pattern
Prototype pattern
Object pool pattern
Summary
3
Behavioral Patterns
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
4
Structural Patterns
Structural Patterns
Adapter pattern
Proxy pattern
Decorator pattern
Bridge pattern
Composite pattern
Façade pattern
Flyweight pattern
Summary
5
Functional Patterns
Functional Patterns
Introducing functional programming
Introducing functional programming in Java
Re-implementing OOP design patterns
Functional design patterns
Summary
6
Let's Get Reactive
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
7
Reactive Design Patterns
Reactive Design Patterns
Patterns for responsiveness
Patterns for resilience
Patterns for elasticity
Patterns for message-driven implementation
Summary
8
Trends in Application Architecture
Trends in Application Architecture
What is application architecture?
Layered architecture
Model View Controller architecture
Service-oriented architecture
Microservices-based Architecture
Serverless architecture
Summary
9
Best Practices in Java
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
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

Functional design patterns

In this section, we are going to learn about the following functional design patterns:

  • MapReduce
  • Loan pattern
  • Tail call optimization
  • Memoization
  • The execute around method

MapReduce

MapReduce is a technique used for massive parallel programming, developed by Google, which emerged as a functional design pattern because of the ease of expression. In functional programming, it is a form of a monad.

Intent

The intent is to break existing tasks into multiple smaller ones, run them in parallel, and aggregate the result (reduce). It is expected to improve performance for big data.

Examples

We will demonstrate the usage of the MapReduce pattern by parsing and aggregating logs from multiple web services based on a given Sleuth span and calculating the overall duration for each hit endpoint. The logs are taken from https://cloud.spring.io/spring-cloud-sleuth/spring-cloud-sleuth.html and split into the corresponding service log file. The following code reads in parallel all the logs...

Previous Section
End of Section 5
Next Section