funkygao/cp-ddd-framework

DDDplus is a Domain-Driven Design enhancement framework that provides tools for modeling, enforcing, and visualizing domain architectures. It enables developers to define business concepts using Java annotations and reverse-engineer codebases into structured domain models. The system supports dynamic plugin loading, extension point orchestration, and static analysis to ensure architectural compliance and encapsulation.

13 changes.

The project was restructured into a multi-module Maven build and renamed to DDDplus, establishing a new runtime core with domain modeling interfaces and a registry system. Significant work focused on implementing a dynamic plugin architecture for hot-swapping business extensions and introducing static analysis rules to enforce architectural standards.

8 changes.

This period focused on introducing comprehensive domain modeling capabilities, including reverse modeling annotations, association object interfaces, and an interceptor framework. The work also established visualization and enforcement tools via a new Maven plugin and AST-based analysis, supported by documentation for a WMS showcase.

A new dddplus-mybatis module has been introduced, providing a Spring-aware MyBatis object factory. This allows MyBatis to automatically inject Spring-managed beans (such as DAOs) into repository implementations, enabling seamless dependency injection for HasMany/HasOne associations within the infrastructure layer.

dddplus-mybatis · medium confidence

Added a new set of documentation files in the \doc/showcase\ directory to illustrate the WMS (Warehouse Management System) domain model and technical implementation. This includes \callgraph.dot\ and \.svg\ files representing the application's call graph, \classlayer.dot\ and \.svg\ files for class layering, \encapsulation.txt\ for encapsulation details, \pkgref.dot\ and \.svg\ for package references, \tech.svg\ for technical implementation details, and \wms.puml\ for PlantUML diagrams. These files serve as visual and textual references for the showcase project's architecture and domain logic.

doc/showcase · high confidence

Added a new guide for reverse modeling that explains how to use the dddplus-maven-plugin to generate business models from code, including steps for DSL annotation with annotations like @Aggregate, @KeyElement, and @KeyUsecase. Included a new document on software architecture quality metrics with references to academic papers. Added configuration files for call graph visualization (callgraph.json) and class/dependency diagrams (classes.puml, dependencies.puml, design.md). Also added a Vim plugin script (reverse\_model.vim) to highlight plain text reverse models in the editor.

doc · high confidence

A new interceptor framework for domain extensions has been introduced in the \io.github.dddplus.runtime.interceptor\ package. This includes the \IExtensionInterceptor\ interface, which defines \beforeInvocation\ and \afterInvocation\ lifecycle hooks, and the \ExtensionContext\ class, which provides runtime context (code, extension instance, method, and arguments) to these interceptors. This enables users to implement custom logic that runs before and after extension method invocations.

dddplus-runtime/src/main/java/io/github/dddplus/runtime/interceptor · high confidence

The dddplus-plugin module introduces a new runtime registry system that enables the dynamic loading of business extension packages (Plugin Jars). The \Container\ class now manages the lifecycle of these plugins, supporting both Spring-based and non-Spring loading strategies. Each plugin is loaded into a dedicated \PluginClassLoader\ with an isolated Spring \ApplicationContext\, ensuring classloader isolation. The system allows specifying a custom \IContainerContext\ implementation to control how beans are resolved from the container, and provides utilities (\FileUtils\, \JarUtils\) to handle file operations and JAR scanning. This change enables hot-swapping or on-demand loading of business logic without restarting the application.

dddplus-plugin · high confidence

A new @AllowedAccessors annotation has been added to the io.github.dddplus.model.encapsulation package. This annotation allows developers to explicitly declare which classes are permitted to access specific methods or constructors. This mechanism helps maintain encapsulation by enabling static scanning tools to verify that only authorized classes can access internal methods, thereby reducing the risk of unintended side effects from broader visibility modifiers.

dddplus-spec/src/main/java/io/github/dddplus/model/encapsulation · high confidence

Added new static analysis rules for the DDDplus framework to enforce architectural standards and prevent misuse. The \ArchitectureEnforcer\ class defines required and optional rules for service, router, partner, activity, and pattern components, while \DDDPlusEnforcer\ enforces usage conventions for extensions, routers, patterns, and policies. These rules ensure that classes adhere to the framework's structural contracts, such as naming conventions, annotation requirements, and layer dependencies.

dddplus-enforce · high confidence

The dddplus-runtime module now includes the core runtime classes for the DDDplus framework. This includes the DDD entry point for locating routers and steps, and the BaseRouter/StepsExecTemplate for orchestrating domain steps and extension points. The change introduces the IReducer interface to control the execution of multiple extension points (e.g., 'fire and forget' for async steps), and adds exception handling interfaces (IExceptionIgnoreProfilerError, IExceptionWeakLogging) to customize logging and profiler metrics for domain extensions.

dddplus-runtime/src/main/java/io/github/dddplus/runtime · high confidence

Added new interfaces in the \io.github.dddplus.model.association\ package to model entity relationships as objects, specifically \BelongTo\ (many-to-one), \HasOne\ (one-to-one), and \HasMany\ (one-to-many). These interfaces allow entities to reference other objects without hard dependencies on external systems like databases or services, enabling cleaner separation of concerns and easier implementation of data loading strategies.

dddplus-spec/src/main/java/io/github/dddplus/model/association · high confidence

Added a new set of Java annotations in the \io.github.dddplus.dsl\ package to support reverse modeling of domain models. This includes \Aggregate\ for defining business model contexts, \KeyElement\ for core business attributes, \KeyBehavior\ for business object behaviors, \KeyFlow\ for business logic flows, \KeyRule\ for business rules, \KeyRelation\ for object relationships, \KeyEvent\ for domain events, and \IVirtualModel\ for identifying missing business objects. These annotations allow developers to declaratively map code to a structured domain model, enabling the extraction of essential business knowledge and facilitating the alignment of code with business concepts.

dddplus-spec/src/main/java/io/github/dddplus/dsl · high confidence

Adds a new \io.github.dddplus.model\ package containing core Domain-Driven Design building blocks. This includes domain model abstractions (\IDomainModel\, \IAggregateRoot\, \IUnboundedDomainModel\, \IBag\), a dirty-tracking mechanism (\DirtyMemento\, \IDirtyHint\) for efficient persistence, and a Specification pattern implementation (\ISpecification\, \AbstractSpecification\) with \And\/\Or\ composition and \Notification\ for validation errors. The package also provides concrete implementations like \BaseAggregateRoot\, \AbstractBusinessNo\, and \Exchange\ for transient data handling.

dddplus-spec/src/main/java/io/github/dddplus/model · high confidence

The \io.github.dddplus.ext\ package now includes core domain extension interfaces (\IDomainExtension\, \IIdentity\, \IPolicy\, \IIdentityResolver\, \IPatternFilter\, \IPlugable\) and a generic \AnyIdentity\ implementation, enabling dynamic routing and business identity resolution. Additionally, the \io.github.dddplus.step\ package introduces domain step interfaces (\IDomainStep\, \IReviseStepsException\, \IRevokableDomainStep\) and a \ReviseStepsException\ implementation for step orchestration, all marked as deprecated in favor of dedicated frameworks like LiteFlow.

dddplus-spec/src/main/java/io/github/dddplus/ext · high confidence

The dddplus-visualization module now includes a comprehensive set of JavaParser-based AST visitors to analyze and extract domain model information from Java source code. This introduces the ability to automatically identify key elements, behaviors, flows, rules, and use cases via annotations, as well as to compute class hierarchy, method distribution, and encapsulation metrics. The system also supports calculating similarity between models using Jaccard index and clustering method names using K-Means, enabling deeper insights into the codebase structure and potential model debt.

dddplus-visualization · high confidence

The dddplus-maven-plugin introduces several new Maven goals for DDDplus users. The 'model' goal performs reverse engineering of the codebase to generate business models, supporting outputs such as PlantUML diagrams, encapsulation diagrams, plain text models, and SQLite database dumps. The 'polymorphism' goal visualizes class hierarchy and inheritance structures. The 'call' goal generates call graphs from JAR files, allowing users to analyze method and class dependencies. Additionally, the 'enforce' goal runs static analysis checks for DDD principles, extension method signatures, and allowed accessors. These tools provide developers with automated visualization and enforcement capabilities for domain-driven design.

dddplus-maven-plugin · high confidence

The DDDplus runtime now includes a new set of Java annotations in the \io.github.dddplus.annotation\ package to support Domain-Driven Design patterns. These include \@Domain\ and \@Step\ (both marked as \@Deprecated\), alongside new annotations for defining business patterns (\@Pattern\), extension points (\@Extension\), routers (\@Router\), policies (\@Policy\), partners (\@Partner\), and interceptors (\@Interceptor\). Additionally, utility annotations for logging (\@LogInfo\) and service governance (\@Governance\) are introduced to facilitate method-level monitoring and AOP-based service management.

dddplus-runtime/src/main/java/io/github/dddplus/annotation · high confidence

The DDDplus runtime now includes a new internal registry system located in the \io.github.dddplus.runtime.registry\ package. This system introduces a set of \\*Def\ classes (such as \DomainDef\, \ExtensionDef\, \PartnerDef\, \PatternDef\, and \PolicyDef\) that index and manage domain artifacts, extension points, and routers. The \DomainArtifacts\ class is now exposed to provide a unified view of domains, steps, and extensions for external integration. The \DDDBootstrap\ component handles the initialization of this registry during the Spring context refresh, ensuring that all beans are properly registered and indexed for dynamic dispatching.

dddplus-runtime/src/main/java/io/github/dddplus/runtime/registry · high confidence

Added new interfaces for the plugin architecture: IPlugin defines the contract for plugins with getCode() and getVersion(), while IPluginListener provides lifecycle hooks (onPrepared, onCommitted) triggered during hot jar reloading. IContainerContext allows plugins to retrieve beans from the container. These interfaces establish the foundation for hot-swappable plugin packages (Pattern/Partner) within the DDDplus framework.

dddplus-spec/src/main/java/io/github/dddplus/plugin · high confidence

A new package-info.java file has been added to the io.github.dddplus package, providing a Javadoc header that describes the DDD Enhancement Framework and its forward and reverse modeling mechanisms for users.

dddplus-spec/src/main/java/io/github/dddplus · high confidence

The project has been renamed from cp-ddd-framework to DDDplus, reflected in the updated README files (README.md, README.zh-cn.md) and the addition of a Code of Conduct. The build system has been updated with a new Makefile for managing build, test, and deployment tasks, alongside configuration files for code coverage (codecov.yml), JDepend analysis, and Lombok. Additionally, a Doxyfile has been added to support call graph generation.

(repo-wide) · high confidence

Added unit tests and showcase code for a Warehouse Management System (WMS) implementation, demonstrating the use of the LiteFlow orchestration engine. The changes include test cases for the \PackFlow\ and \CheckingAppService\ (manual check), as well as domain models like \Carton\, \ShipmentOrder\, and \Task\. The test suite covers reverse modeling, call graph analysis, and encapsulation reporting for the WMS domain, alongside integration tests for LiteFlow components such as \BindEncryptPrintLabelData\ and \GetWaybillFromExternal\.

dddplus-test · high confidence

The DDDplus framework now includes dedicated Maven modules for its core components: enforce, maven-plugin, mybatis, plugin, runtime, spec, and visualization. Each module is defined in its own pom.xml, establishing a multi-module project structure that supports building, testing, and deploying these distinct parts of the framework independently.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 57 → 70 (+12.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 90 → 94 (+3.3)
• Architecture 97 → 100 (+2.6)
• Maturity 70 → 69 (-0.1)
• Readiness 73 → 73 (+0.0)
• Security 38 → 64 (+26.3)
• Domain Modelling 74 → 80 (+5.4)

• Boundary-crossing change coupling: KeyBehavior.java ↔ KeyFlowAnnotationParser.java (dddplus-spec/src/main/java/io/github/dddplus/dsl/KeyBehavior.java)
• Boundary-crossing change coupling: KeyFlow.java ↔ KeyFlowAnnotationParser.java (dddplus-spec/src/main/java/io/github/dddplus/dsl/KeyFlow.java)
• Boundary-crossing change coupling: KeyFlow.java ↔ KeyFlowEntry.java (dddplus-spec/src/main/java/io/github/dddplus/dsl/KeyFlow.java)
• Change coupling: KeyBehavior.java ↔ KeyFlow.java (dddplus-spec/src/main/java/io/github/dddplus/dsl/KeyBehavior.java)
• Change coupling: KeyFlowAnnotationParser.java ↔ PlantUmlRenderer.java (dddplus-visualization/src/main/java/io/github/dddplus/ast/parser/KeyFlowAnnotationParser.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (11 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/parser/KeyBehaviorAnnotationParser.java)
• Duplicated block (12 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/parser/KeyFlowAnnotationParser.java)
• Duplicated block (12 lines × 3) (dddplus-visualization/src/main/java/io/github/dddplus/ast/KeyBehaviorAstNodeVisitor.java)
• Duplicated block (6 lines × 2) (dddplus-maven-plugin/src/main/java/io/github/dddplus/maven/ClassHierarchyMojo.java)
• Duplicated block (7 lines × 2) (dddplus-runtime/src/main/java/io/github/dddplus/runtime/registry/PartnerDef.java)
• Duplicated block (7 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/KeyElementAstNodeVisitor.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 14 more

• Coverage not measured — no coverage collector is wired up
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/KeyElementAstNodeVisitor.java)
• Duplicated block (10 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/parser/KeyBehaviorAnnotationParser.java)
• Duplicated block (11 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/model/KeyBehaviorEntry.java)
• Duplicated block (16–17 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/parser/KeyFlowAnnotationParser.java)
• Duplicated block (19 lines × 3) (dddplus-visualization/src/main/java/io/github/dddplus/ast/KeyBehaviorAstNodeVisitor.java)
• Duplicated block (26 lines × 2) (dddplus-spec/src/main/java/io/github/dddplus/model/ListBag.java)
• Duplicated block (7 lines × 2) (dddplus-runtime/src/main/java/io/github/dddplus/runtime/registry/PartnerDef.java)
• Duplicated block (7 lines × 2) (dddplus-visualization/src/main/java/io/github/dddplus/ast/report/KeyBehaviorReport.java)
• Duplicated block (7–8 lines × 3) (dddplus-maven-plugin/src/main/java/io/github/dddplus/maven/ClassHierarchyMojo.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 16 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

funkygao/cp-ddd-framework was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.