Tagged articles
repository pattern
24 articles · Page 1 of 1
This article defines software architectural styles through components, connectors, constraints, and computational models, detailing six classic styles—Pipe-and-Filter, Object-Oriented, Event-Driven, Layered, Repository, and Interpreter—with their invariants, examples, advantages, disadvantages, and specializations, plus heterogeneous architecture combinations.
Layered Architecturearchitectural stylesevent-driven
0 likes · 16 min read

The article explains that in Domain‑Driven Design a Repository should target the aggregate, not individual tables, because the aggregate defines a consistency boundary; having separate repositories for master and detail tables breaks this boundary, allowing inconsistent writes and bypassing the aggregate root’s validation.
Aggregate RootConsistency boundaryDDD
0 likes · 9 min read

The article explains the definition of software architecture styles, enumerates classic styles such as data‑flow (batch and pipeline‑filter), call/return, object‑oriented, layered, independent component (process‑communication and event‑driven), virtual‑machine (interpreter and rule‑based), and repository (database and blackboard), and provides concrete examples and a mnemonic to help remember their characteristics and suitable application scenarios.
Layered Architecturearchitecture stylesdata flow
0 likes · 9 min read

This article explains how the Ecotone framework lets PHP developers map classes to database tables, hide low‑level SQL behind repository interfaces, customize parameter conversion with converters and expression language, and efficiently query, update, and stream large result sets while keeping business logic clean.
Database MappingEcotonePHP
0 likes · 20 min read

This guide explains the repository pattern for Laravel, detailing its benefits, step‑by‑step implementation for an e‑commerce product management module—including model, interface, repository, controller code—and offers best practices, caching tips, and common pitfalls to improve code structure, maintainability, and testability.
CachingLaravelPHP
0 likes · 9 min read

The Repository pattern in Flutter abstracts data access behind a type‑safe interface, isolating domain models from API, database, or device details, enabling easy swapping of implementations, simplifying testing with mocks, and promoting clean architecture by keeping UI code separate from business and networking logic.
DartFlutterdependency-injection
0 likes · 15 min read

The article examines the difficulties of applying Domain-Driven Design to a cloud‑disk file‑upload scenario, demonstrates how to simplify the code by extracting business models, introducing factories and repositories, and explains how these patterns clarify the separation between business and technical concerns.
Factory PatternJavadomain-driven design
0 likes · 20 min read

The article compares redundant and normalized storage, explains their trade‑offs, and introduces an in‑memory aggregation technique implemented via a repository "fill" method in Java, showing how to replace costly SQL joins with flexible, code‑driven data merging while preserving consistency and performance.
Database DesignDenormalizationIn-Memory Join
0 likes · 11 min read

This article explores the fundamentals of Domain‑Driven Design, its challenges, practical steps for applying DDD concepts such as value objects, repository patterns, hexagonal architecture, and domain layer design, and shares concrete refactoring experiences to build more maintainable, extensible, and testable systems.
DDDdomain-driven designhexagonal-architecture
0 likes · 20 min read

This article explains how Domain‑Driven Design (DDD) combined with Spring Data JPA enables clean, object‑oriented modeling of order workflows, introduces the Repository pattern for persistence, and demonstrates the full lifecycle—from creation to address modification and payment—through concise Java code and SQL examples.
DDDJavaSpring Data JPA
0 likes · 21 min read

This article explores Domain‑Driven Design fundamentals, illustrating how to expose hidden concepts, adopt hexagonal architecture, and implement repository patterns to achieve high scalability, maintainability, and testability in complex software systems, while addressing common pitfalls like the anemic model.
DDDanemic modeldomain-driven design
0 likes · 23 min read

This article explains how domain‑driven design (DDD) leverages object‑oriented principles and the Repository pattern, demonstrates integrating Spring Data JPA for persistence, and walks through a complete order lifecycle—including creation, address modification, and payment—showcasing lazy loading, automatic synchronization, and practical unit‑test examples.
DDDJavaSpring Data JPA
0 likes · 22 min read

This article explains how a WeChat team used Domain‑Driven Design to improve the maintainability, scalability, and stability of a fast‑paced, multi‑team e‑commerce project, covering strategic and tactical modeling, layered architecture, subdomains, bounded contexts, anti‑corruption layers, domain events, aggregates, repositories, and a practical code scaffold with C++ examples.
DDDcqrsdomain-driven design
0 likes · 18 min read

This article explores the challenges of implementing Repository in Domain‑Driven Design, introduces the innovative “Repository Entity Transfer” concept, compares in‑memory and relational implementations, discusses concurrency, specifications, and architectural patterns, and provides practical code examples to help developers build cleaner, model‑centric back‑end systems.
Entity Transferbackend architecturedomain-driven design
0 likes · 32 min read

This article explains the fundamentals of Domain‑Driven Design, compares it with traditional MVC, details layered architecture, data transformation objects, core concepts like aggregates and domain events, and provides a full Java SpringBoot DDD demo with code, project structure, database schema, and deployment steps.
DDDJavaSpringBoot
0 likes · 32 min read

This article explores the concept of fully interface‑based domain modeling, demonstrates how to design domain objects as interfaces, shows repository implementations for JPA, MyBatis and Elasticsearch, discusses association handling, and explains how such designs enable seamless switching between monolithic, clustered and microservice deployments.
JavaSpringbackend development
0 likes · 11 min read

This article walks through the core functionalities and business flows of a single‑database order system—covering user order placement, order list queries, detail views, and cancellations—while explaining how Controller, Service, Repository, and Mapper components interact within the backend architecture.
ControllerService LayerWorkflow
0 likes · 6 min read

This article explores comprehensive domain interface design in Java backend development, showing how to model domain objects as interfaces, implement repositories for JPA, MyBatis, and Elasticsearch, handle associations with JPA annotations, and apply these patterns in the open‑source Mallfoundry e‑commerce platform.
ElasticsearchJPAJava
0 likes · 8 min read

This guide introduces the think-repository package for ThinkPHP 6, explains how to install it via Composer, demonstrates common repository methods for CRUD operations, routing, and transformer generation, and provides code examples for integrating the repository into multi‑application back‑end projects.
CRUDComposerThinkPHP
0 likes · 4 min read

Domain‑Driven Design, a mindset rather than a rigid methodology, clarifies business complexity through a central domain model, layered and hexagonal architectures, bounded contexts, and repository patterns—dispelling myths that it suits only large projects or adds excessive boiler‑plate, and showing practical Java implementation.
Javaclean architecturedomain-driven design
0 likes · 20 min read

This article shares practical experiences and techniques for Android app development, covering entity class organization, graceful network data handling with Retrofit, robust repository patterns, and clean UI layering using MVVM, DataBinding, and LiveData.
AndroidDataBindingEntity Design
0 likes · 8 min read

The article shows how to apply Domain‑Driven Design to construct an education‑sector lead management system, detailing the four‑layer architecture, a four‑color prototype analysis for requirements, core DDD concepts such as entities, value objects, aggregates and repositories, and a concrete implementation of domain models and services.
Aggregate DesignDDD ArchitectureFour-Color Prototype
0 likes · 18 min read

This article explores practical Domain‑Driven Design in a B‑to‑B setting, comparing data‑centric and object‑centric modeling, illustrating blood‑loss, anemia, and rich models, and showing how dependency injection, testing strategies, repository abstractions, and deployment architectures can improve software quality and maintainability.
Software Modelingbackend architecturedependency-injection
0 likes · 15 min read

This article explores the definitions of SOA and DDD, explains DDD's layered architecture, demonstrates how business relationships become domain models, and provides concrete C# examples of repositories, services, and factories to illustrate the integration of service‑oriented architecture with domain‑driven design.
C#DDDSOA
0 likes · 18 min read
