Design Patterns and Best Practices in Java电子书

Title Page

Copyright and Credits

Design Patterns and Best Practices in Java

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the authors

About the reviewer

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

Download the color images

Conventions used

Get in touch

Reviews

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

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

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

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

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

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

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

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

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

Leave a review - let other readers know what you think