This article explains Alibaba’s Java development guidelines for layered domain models, detailing the purpose and naming rules of DO, DTO, BO, AO, VO, and Query objects, and clarifies the roles of PO, VO, DAO, BO, DTO, and POJO in clean backend architecture.
This article explains the importance of clear application layering, compares Alibaba's multi‑layer architecture with optimized practices, details the conversion between various domain models (DO, DTO, BO, AO, VO, Query), and provides guidelines for maintaining clean responsibilities across Controller, Service, Manager, and DAO layers.
The article explains Domain‑Driven Design’s philosophy of aligning business language with code, defines key concepts such as bounded contexts, entities, value objects, aggregates, and shows how these ideas translate into microservice decomposition, event‑driven integration, and reduced coupling for cloud‑native systems.
This article presents a comprehensive guide on constructing domain-specific large language models, covering the differences from general models, how to build high‑quality domain datasets, selecting appropriate training methods, designing validation sets, evaluating model capabilities, and benchmarking domestic hardware performance.
This article explains the importance of proper application layering in backend development, outlines Alibaba’s recommended layer structure, suggests optimizations for service and manager layers, describes domain model conversions such as DO, DTO, BO, and concludes with best‑practice recommendations for maintainable, clear‑boundary code.
This article explains the importance of proper application layering, compares Alibaba's recommended layer structure with an optimized model, describes the corresponding domain objects for each layer, and offers practical advice for building maintainable, reusable backend systems.
The article explains why clear application layering—covering controller, service, manager, and DAO levels—is essential for maintainable backend code, reviews Alibaba's recommended layer structure, proposes an optimized layering model, and discusses domain model conversions to avoid excessive object transformations.
This article explains Alibaba's Java development specifications for layered domain models, detailing the roles, naming conventions, and usage of objects such as DO, DTO, BO, VO, PO, DAO, and POJO to improve code organization and reduce coupling across application layers.
This article explains the Alibaba Java development specification for layered domain models, detailing the purpose and naming conventions of DO, DTO, BO, AO, VO, Query objects, and further clarifies the roles of PO, VO, DAO, BO, DTO, and POJO in Java backend architecture.
The article discusses the importance of clear application layering, outlines Alibaba’s multi‑layer architecture, proposes an optimized layering model, explains domain object types (DO, DTO, BO, AO, VO, Query) and offers practical guidelines to improve code maintainability and reuse in backend development.
This article examines common misconceptions about application layering, outlines Alibaba's multi‑layer architecture—including Open Interface, Terminal Display, Web, Service, Manager, and DAO layers—offers optimized layering practices, explains domain model transformations, and provides actionable guidelines for building maintainable, reusable backend systems.
This article examines common pitfalls in application layering, outlines Alibaba's recommended multi‑layer architecture, proposes an optimized layering approach with clear responsibilities for controllers, services, managers, and DAOs, and discusses domain model conversions to improve maintainability and team collaboration.
This article discusses the importance of proper backend application layering, outlines Alibaba's multi‑layer architecture (controller, service, manager, DAO, etc.), explains domain model transformations (DO, DTO, BO, VO, etc.), and offers practical recommendations for achieving clear responsibilities and maintainable code.
The article explains why clear application layering—covering controller, service, manager, and DAO levels—is essential for maintainable backend code, describes Alibaba's recommended layer structure, proposes an optimized layering model, and outlines domain object conventions such as DO, DTO, BO, AO, VO, and Query.
This article examines common misconceptions about application layering, outlines essential criteria for effective layering, details Alibaba's official multi‑layer architecture, proposes an optimized layering approach with clear responsibilities for controllers, services, managers, and DAOs, and explains domain model conversions across layers.
This article explains the importance of clear responsibility separation in application layering, reviews Alibaba's recommended layer structure, proposes an optimized layering model, and discusses domain model conversions to improve code maintainability, reusability, and team collaboration.
The article explains the importance of clear application layering, compares Alibaba's recommended multi‑layer architecture with practical optimizations, describes each layer’s responsibilities, discusses domain model transformations, and offers guidelines for maintaining clean, reusable, and maintainable backend code.
This article presents a lightweight, domain‑model‑based layered architecture for Java backend development, detailing six layers (web, biz, dal, client, common, facade), their package structures, call relationships, layer conventions, and providing reusable code snippets and utilities to guide clean and maintainable application design.
This comprehensive guide walks you through selecting and applying the right UML diagrams at each project stage—from initial scope and feasibility studies, through requirement analysis and use‑case modeling, to system design, domain modeling, and detailed interaction diagrams—illustrated with two practical case studies.
This article explains how domain‑driven design shifts database modeling from a data‑structure‑first approach to a domain‑model‑centric process, covering persistence of domain objects, the conversion of the four classic relational relationships and inheritance into tables, and the distinct strategies required for NoSQL databases.
This article introduces the essential principles of Domain‑Driven Design, explaining its two‑stage approach, key building blocks such as entities, value objects, aggregates, factories, repositories, services, and domain events, and shows how DDD fits into layered architecture and common anti‑patterns.
This article explains the concept, purpose, and essential practices of domain modeling, covering UML relationship types, code examples, model simplification tips, and common pitfalls to help developers create clear, business‑focused class diagrams.
This article explains why clear application layering matters, outlines Alibaba's recommended layers, proposes an optimized layering approach, details domain model mappings for each layer, and offers practical tips to improve maintainability and team collaboration in backend development.
This article explains the importance of clear application layering, reviews Alibaba's recommended layer structure, proposes an optimized layering model, and discusses domain model transformations to improve code maintainability and reuse in backend development.
This article explains the definitions of domain and data models, illustrates why they are often confused, shows real‑world examples of misusing each, and provides practical guidance on separating them to improve system design, scalability, and maintainability.
The article explains common misconceptions about application layering, presents Alibaba's multi‑layer architecture (open‑interface, terminal display, web, service, manager, DAO), proposes an optimized layering model with RPC, and discusses domain‑model conversions such as DO, DTO, BO, AO, VO and Query to achieve clear responsibilities and maintainable code.
The article discusses the importance of clear responsibilities in application layering, compares Alibaba's multi‑layer architecture with an optimized model, explains domain object types across layers, and offers practical guidelines to improve maintainability and reuse in backend systems.
This article examines why monolithic, tangled codebases—dubbed the Big Ball of Mud—fail due to performance, complexity, and organizational mismatches, and presents a series of concrete architectural remedies such as domain modeling, service decomposition, ESB avoidance, asynchronous messaging, and event sourcing to achieve stable, maintainable systems.
The article explains why clear separation of responsibilities among controller, service, manager, and DAO layers is essential for maintainable backend code, outlines Alibaba's layered architecture guidelines, proposes an optimized layering model, and discusses domain model conversions across layers to avoid excessive object transformations.
