iluwatar / iluwatar/java-design-patterns

Domain-Oriented Microservice Architecture (DOMA)

Open
#1,336 7 comments 0 reactions 0 assignees View on GitHub

Nobody has claimed this yet.

epic: architecture epic: pattern info: help wanted type: feature
Dominant language
Java
Stars
94.7k
Forks
27.4k
Avg merge
3d 4h
Merged PRs (30d)
10

Description

Description:
The Domain-Oriented Microservice Architecture (DOMA) design pattern focuses on organizing microservices around business domains to improve scalability, flexibility, and maintainability. This pattern leverages domain-driven design principles to ensure that each microservice is aligned with a specific business capability, enabling independent development, deployment, and scaling. The main elements of this pattern include:

  1. Domain-Driven Design (DDD): Using DDD principles to identify and model the core domains and subdomains of the business.
  2. Microservices: Decomposing the application into smaller, loosely coupled services, each responsible for a specific domain or subdomain.
  3. Bounded Contexts: Defining clear boundaries for each microservice to ensure they encapsulate their domain logic and data.
  4. API Gateway: Implementing an API gateway to manage communication between clients and the microservices, providing a unified entry point.
  5. Service Discovery: Utilizing service discovery mechanisms to enable dynamic resolution of microservice instances.
  6. Data Management: Ensuring each microservice has its own data store, promoting data autonomy and consistency within the domain.

References:

Acceptance Criteria:

  1. Identify and document the core domains and subdomains of the application using DDD principles.
  2. Develop and deploy at least one microservice for a critical domain, ensuring it follows the bounded context and has its own data store.
  3. Implement an API gateway and service discovery mechanism to facilitate communication and dynamic resolution between microservices.

Contributor guide

Open the contributing guide

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

Research direction

No files, tests, or entry points are named. Start by inspecting the repository structure and existing design-pattern implementations to determine where a DOMA example could belong. Define the core domains and bounded contexts, then establish the required microservice, data store, API gateway, and service discovery components as the completion criteria.

Written by the indexing model from the issue text.

Assessment

Tech stack
java
Domain
backend-api-design, distributed-systems
Issue type
Feature
Difficulty
5/5
Estimated time
Over a week
Activity status
Stale
Clarity
Needs clarification
Newbie friendliness
15/100

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.