Architectural Patterns电子书

Title Page

Copyright

Architectural Patterns

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Downloading the color images of this book

Errata

Piracy

Questions

Demystifying Software Architecture Patterns

Envisioning the software-defined world

Software patterns

Why software patterns?

The prime ingredients of a software pattern

The types of software patterns

Software architecture patterns

Object-oriented architecture (OOA)

Component-based assembly (CBD) architecture

Domain-driven design (DDD) architecture

Client/server architecture

Multi-tier distributed computing architecture

Layered/tiered architecture

Event-driven architecture (EDA)

The major issues with EDA

Service-oriented architecture (SOA)

Service-inspired integration (SOI)

Event-driven service-oriented architecture

The EDA fundamental principles

The ED-SOA composite pattern benefits

Microservices architecture (MSA)

Event-driven microservices patterns

Space-based architecture (SBA)

Combining architecture patterns

Special-purpose architectures

Real-time context-aware prediction architecture

Summary

Additional reading materials

Client/Server Multi-Tier Architectural Patterns

Domain name service (DNS) server and DNS client

The workings of a DNS

Functional requirements in two-tier client-server patterns

Distribution of functional requirements in a client-server pattern

The remote data access client-server pattern

The remote presentation client-server pattern

The split logic data client-server architecture pattern

The three-tier pattern / multi-tier pattern client-server

The master-slave pattern

Issues in the master-slave pattern

Peer-to-peer patterns

Advantages of two-tier client-server patterns

Design considerations - when to use a two-tier client-server pattern?

Limitations of two-tier client-server patterns

Three-tier client-server architecture

Design considerations for using three-tier architecture

Design considerations for n-tier architecture

An example of n-tier architecture (shopping cart web application)

The distributed client-server architecture

Motivation for development of web application patterns

Workings of the MVC pattern

The ASP.Net framework

The model view presenter (MVP) pattern

The model-view-viewmodel (MVVM) pattern

Key advantages of the MVVM pattern

Design considerations for using the MVVM pattern

Prism

Design patterns for web application development

The front controller pattern

Spring framework

Summary

Object-Oriented Software Engineering Patterns

Key elements of OOD

Additional elements of OOD

Design principles

Single responsibility principle (SRP) – SOLID

Open and close principle – SOLID

Liskov substitution principle (LSP) – SOLID

Interface segregation principle (ISP) – SOLID

Dependency inversion principle (DIP) – SOLID

Other common design principles

OO design patterns

Creational design patterns

Factory method (virtual constructor)

Abstract factory (kit)

Builder

Prototype

Singleton

Structural design patterns

Adapter class (wrapper)

Adapter (object)

Bridge (handle/body)

Composite

Decorator

Façade

Flyweight

Proxy

Behavioral patterns

Chain of responsibility

Command (action/transaction)

Interpreter

Iterator (cursor)

Mediator

Memento

Observer (dependents/publish/subscribe)

State (objects for states)

Strategy (policy)

The template method

Visitor

Concurrency patterns

Concurrency design pattern

Producer-consumer

Active object

Monitor object

Concurrency architectural pattern

Summary

References

Enterprise Integration Patterns

Need for integration patterns

Integration scenarios in enterprises

Information portal

Data replication

Shared business function

Service-oriented architecture

Distributed business process management

The business-to-business integration

Main challenges in enterprise integration

File transfer

Shared database

Remote procedure invocation

Messaging

Getting started with messaging patterns

Pipe and filter pattern

Message router pattern

Message translator pattern

Message endpoint pattern

Point-to-point channel pattern

Publish-subscribe channel pattern

Datatype channel pattern

Message bus patterns

Command message patterns

Event message patterns

Request-reply pattern

Content-based router pattern

Message filter pattern

Resequencer pattern

Polling consumer pattern

Channel adapter

Mobile integration pattern

Request-response pattern

Defining a push notification pattern

API management pattern

Summary

Domain-Driven Design (DDD) Principles and Patterns

Principles, characteristics, and practices of DDD

Principles

Focusing on the core domain

Collaborate and learn

Model the domain

Evolve

Talk in ubiquitous language

Characteristics

Best practices

DDD patterns

Strategic patterns

Ubiquitous language

Domain, subdomain, and core domain

Bounded contexts

Integrating bounded contexts

Autonomous bounded context

The shared-nothing architecture

Single responsibility codes

Multiple bounded contexts (within a solution)

Adoption of SOA principles

Integrating with legacy systems

The bubble context

The anti-corruption layer

Expose as a service

Distributed bounded context integration strategies

Database integration

Flat file integration

Event-driven architecture and messaging

Tactical patterns

Patterns to model the domain

Entities

Value objects

Domain services

Modules

Aggregates

Factories

Repositories

Emerging patterns

Domain events

Event sourcing

Other patterns

Summary

References and further reading materials

Enterprise Architecture Platforms and Tools

Overview of enterprise architecture frameworks

Getting started with TOGAF

Architecture development method (ADM)

Deliverables, artifacts, and building blocks

Enterprise continuum

Architecture repository

Advantages of using TOGAF

Limitations of TOGAF

Zachman framework for enterprise architecture

Advantages

Restrictions

Guidelines for choosing EAF

Enterprise architecture platforms and tools

Enterprise Architect from Sparx Systems

Dragon1

ABACUS from avolution software

Architecture of ABACUS

Summary

References

Service-Oriented Architecture (SOA)

Web services and SOA

Introduction to SOA

Life cycle of SOA

Primary characteristics of SOA

Service interconnectivity with well-defined interfaces

Standard interfaces and Service level agreements

Event-driven and messaging

Flexible

Evolution

Principles of SOA

Standardized service contract

Service interoperability

Service abstraction

Service autonomy

Service composability

Service discoverability

Service loose coupling

Service reusability

Service statelessness

SOA design patterns

Service messaging

Message screening

Agnostic services

Atomic service transaction

Authentication broker

Message origin authentication

Service façade

Multiple service contract

Service callback

Event-driven messaging

Service refactoring

Metadata centralization

Principles and patterns cross reference

Summary

Event-Driven Architectural Patterns

Service-oriented architecture and event-driven architecture (SOA versus EDA)

Key characteristics of event-driven patterns

Components of an EDA pattern

Event flow layers

Event generators

Event channel

Event processing

Downstream event-driven activity

Design considerations for event-driven patterns

Implementation variants of EDA patterns

Simple event processing patterns

Event stream processing patterns

Complex event processing (CEP) patterns

Types of event-driven patterns

Event mediator topology pattern

Event broker topology pattern

Hub and spoke pattern

Broadcast pattern

Polling pattern

EDA pattern implementation in systems/processes

Event log

Event collectors

Reply queue

Improving the performance of EDA-based processes/systems

IBM WebSphere MQ

Emerging trends in EDA

Event-driven microservices

Complex event processing

Internet of Things (IoT) and EDA

References

Summary

Microservices Architecture Patterns

Microservices patterns

Decomposition patterns

Decomposition by use case pattern

Decomposition by resources pattern

Decomposition by business capability pattern

Decomposition by subdomain pattern

Microservices deployment pattern

Multiple service instances per host pattern

Single service instance per host pattern

Service instance per VM pattern

Service instance per container pattern

Serverless deployment pattern

Service deployment platform pattern

Microservices design patterns

Aggregator microservice design pattern

Proxy microservice design pattern

Chained microservice design pattern

Microservice chassis pattern

Externalized configuration pattern

Microservices database patterns

Database per service pattern

Shared data design pattern

Shared database pattern

Command-query responsibility segregation (CQRS) pattern

Microservices integration patterns

Remote procedure invocation (RPI) pattern

Messaging design pattern

Asynchronous messaging design pattern

Domain-specific protocol pattern

API gateway pattern

Backend for frontend pattern

Microservices registration, discovery, and usage patterns

Service discovery pattern

Service registry pattern

Service registration pattern

Event-driven architecture (EDA) patterns

Event sourcing pattern

Transaction log tailing pattern

Publishing events using the database trigger pattern

Application publishes events pattern

Testing and troubleshooting patterns

Access token pattern

Service component test pattern

Log aggregation pattern

Application metrics pattern

Audit logging pattern

Distributed tracing pattern

Exception tracking pattern

Health check API pattern

Microservices composition patterns

Server-side page fragment composition pattern

Client-side UI composition pattern

Messaging-based microservices composition pattern

Resilient and reliable microservices patterns

Circuit breaker pattern

Shared caching layer pattern

High availability microservices pattern

Concurrent requests for data pattern

Event store pattern

Event streams and the unified event log pattern

Asynchronous command calls pattern

Summary

Patterns for Containerized and Reliable Applications

Introduction

The key drivers for containerization

Design patterns for Docker containers

Container building patterns

Docker image building patterns

Multi-stage image building pattern

The pattern for file sharing between containers

Using bind-mount volumes

Pipes and filters pattern

Containerized applications - Autopilot pattern

Containers - persistent storage patterns

The context for persistent storages

The persistent storage options

Volumes

Bind mounts

The tmpfs mounts

Docker compose configuration pattern

Docker container anti-patterns

Installing an OS inside a Docker container

Go for optimized Docker images

Storing container images only inside a container registry

Hosting only one service inside a container

Latest doesn't mean best

Docker containers with SSH

IP addresses of a container

Root user

Dependency between containers

Patterns for highly reliable applications

Resiliency implementation strategies

The testing approaches for resiliency

The resilient deployment approaches

The deployment patterns

Monitoring and diagnostics

Resiliency realization patterns

Circuit breaker pattern

Bulkhead pattern

Compensating transaction pattern

Health endpoint monitoring pattern

Leader election pattern

Queue-based load leveling pattern

Retry pattern

Summary

Software-Defined Clouds - the Architecture and Design Patterns

Reflecting the cloud journey

Traditional application architecture versus cloud application architecture

The traditional application architecture

The cloud architecture

The cloud application architecture

Cloud integration patterns

Tier/Layer-based decomposition

Process-based decomposition

Pipes-and-filters-based decomposition

Service messaging pattern

Messaging metadata pattern

Service agent pattern

Intermediate routing pattern

State messaging pattern

Service callback pattern

Service instance routing

Asynchronous queuing pattern

Reliable messaging pattern

Cloud design patterns

Cache-aside pattern

Circuit breaker pattern

Compensating transaction pattern

Competing consumers pattern

Compute resource consolidation pattern

Command and query responsibility segregation (CQRS) pattern

Event sourcing pattern

External configuration store pattern

Federated identity pattern

Gatekeeper pattern

Application health monitoring pattern

Leader election pattern

Materialized views pattern

Pipes and filters pattern

Priority queue pattern

Queue-based load leveling pattern

Retry pattern

Runtime reconfiguration pattern

Scheduler agent supervisor pattern

Sharding pattern

Throttling pattern

Workload distribution pattern

Cloud workload scheduler pattern

Cloud reliability and resilience patterns

Resource pooling pattern

Resource reservation pattern

Hypervisor clustering pattern

Redundant storage pattern

Dynamic failure detection and recovery pattern

Redundant physical connection for virtual servers pattern

Cloud security patterns

Cryptographic key management system pattern

Virtual private network (VPN) pattern

Cloud authentication gateway pattern

In-transit cloud data encryption pattern

Cloud storage device masking pattern

Cloud storage data at rest encryption pattern

Endpoint threat detection and response pattern

Threat intelligence processing pattern

Cloud denial of service (DoS) protection pattern

Summary

Bibliography

Big Data Architecture and Design Patterns

The four V's of big data

Big data analysis and technology concepts

Data analysis life cycle

Big data analysis and data science

Data analysis

Data science

Big data platform

Big data engineering

Big data governance

Big data architecture landscape and layers

Big data architecture patterns

MapReduce pattern

Lambda architecture pattern

Data lake architecture pattern

Big data design patterns

Data sources and ingestion layer

Multisource extractor

Multidestination pattern

Protocol converter

Just-In-Time (JIT) transformation pattern

Real-time streaming pattern

Big data workload patterns

Data storage layer

ACID versus BASE versus CAP

Façade pattern

NoSQL pattern

Polyglot pattern

Data access layer

Connector pattern

Lightweight stateless pattern

Service locator pattern

Near real-time pattern

Stage transform pattern

Rapid data analysis pattern

Data discovery and analysis layer

Data queuing pattern

Index-based insight pattern

Machine learning pattern

Converge(r) pattern

Data visualization layer

First glimpse pattern

Portal pattern

Mashup view pattern

Compression pattern

Exploder pattern

Summary

References