Architecture Patterns Learning Path

Architecture patterns are reusable ways to organize software systems.

They help you decide:

• How responsibilities should be separated.
• How layers should communicate.
• How business logic should be protected.
• How services should coordinate.
• How systems should scale, recover, and evolve.

This page is the home article for the Architecture Patterns section. Use it as the ordered table of contents for the complete series.

The order below also controls the Previous and Next navigation at the bottom of each article in this folder.

Complete Architecture Pattern Order

Foundational Application Architecture Patterns

These patterns help structure application code clearly inside a service or monolith.

No	Pattern	Use When
24	MVC Architecture Pattern in Java	You want to separate user interface, request handling, business logic, and model data
25	Front Controller Design Pattern in Java	You want one central entry point for request routing, authentication, logging, and common web concerns
26	Dependency Injection Pattern in Java	You want loose coupling by injecting dependencies instead of creating them directly
27	Repository Pattern in Java	You want to isolate domain logic from data access details
28	DAO (Data Access Object) Pattern in Java	You want a dedicated object to handle low-level database operations
29	DTO (Data Transfer Object) Pattern in Java	You want clean request and response objects without exposing internal entities
30	Service Layer Pattern in Java	You want business use cases coordinated in a clear application service layer

Distributed and Microservice Architecture Patterns

These patterns help build scalable, resilient, and evolvable distributed systems.

No	Pattern	Use When
31	CQRS (Command Query Responsibility Segregation) Pattern in Java	You want to separate write models from read models for scalability or clarity
32	Event Sourcing Pattern in Java	You want to store state changes as a sequence of events instead of only the latest state
33	Saga Pattern in Java Microservices	You need to manage distributed transactions across multiple services
34	Circuit Breaker Pattern in Java Microservices	You want to prevent cascading failures when downstream services are slow or unavailable
35	API Gateway Pattern in Microservices	You need a single entry point for clients, routing, authentication, rate limiting, and aggregation
36	Outbox Pattern in Java Microservices	You need reliable event publishing together with database updates
37	Service Discovery Pattern in Microservices	You need services to locate each other dynamically in cloud or container environments
38	Strangler Fig Pattern in Microservices	You want to migrate a legacy system gradually without a risky big-bang rewrite
39	Observer Pattern in Microservices	You want services or components to react to domain events without tight coupling
40	Event Driven Architecture (EDA) in Microservices	You want services to communicate asynchronously through events

Recommended Learning Flow

flowchart TD
    A["Application Structure"] --> A1["24 MVC"]
    A1 --> A2["25 Front Controller"]
    A2 --> A3["26 Dependency Injection"]
    A3 --> A4["27 Repository"]
    A4 --> A5["28 DAO"]
    A5 --> A6["29 DTO"]
    A6 --> A7["30 Service Layer"]

    A7 --> B["Distributed Architecture"]
    B --> B1["31 CQRS"]
    B1 --> B2["32 Event Sourcing"]
    B2 --> B3["33 Saga"]
    B3 --> B4["34 Circuit Breaker"]
    B4 --> B5["35 API Gateway"]
    B5 --> B6["36 Outbox"]
    B6 --> B7["37 Service Discovery"]
    B7 --> B8["38 Strangler Fig"]
    B8 --> B9["39 Observer in Microservices"]
    B9 --> B10["40 Event Driven Architecture"]

How to Study This Series

If you are learning architecture patterns for the first time, follow the numeric order.

If you are working on application design:

• Start with MVC, Front Controller, Dependency Injection, Repository, DAO, DTO, and Service Layer.

If you are working on microservices or system design:

• Start with CQRS, Event Sourcing, Saga, Circuit Breaker, API Gateway, Outbox, Service Discovery, Strangler Fig, Observer, and Event Driven Architecture.

Each article explains the pattern intent, problem it solves, Java implementation approach, architecture trade-offs, and where it fits in real enterprise systems.