java中的DDD思想指的是什么及在Java中的体现详解

+---------------------+
|   用户接口层（ui layer）     |  ← http、web、rpc 接口
+---------------------+
|   应用层（application layer） |  ← 用例协调、事务控制
+---------------------+
|   领域层（domain layer）     |  ← 核心业务逻辑、实体、聚合、领域服务
+---------------------+
|   基础设施层（infrastructure layer）| ← 数据库、消息、外部服务调用
+---------------------+

// 值对象：金额
public class money {
    private bigdecimal amount;
    private string currency;
 
    public money(bigdecimal amount, string currency) {
        this.amount = amount;
        this.currency = currency;
    }
 
    public money add(money other) {
        if (!this.currency.equals(other.currency)) throw new illegalargumentexception();
        return new money(this.amount.add(other.amount), currency);
    }
}
 
// 实体：订单项
public class orderitem {
    private long id;
    private string productname;
    private money price;
    private int quantity;
}
 
// 聚合根：订单
public class order {
    private long id;
    private list<orderitem> items = new arraylist<>();
    private money total;
    private string status;
 
    public void additem(orderitem item) {
        this.items.add(item);
        this.total = this.total.add(item.getprice().multiply(item.getquantity()));
    }
 
    public void confirm() {
        if (this.status.equals("created")) {
            this.status = "confirmed";
            // 发布领域事件
            domaineventpublisher.publish(new orderconfirmedevent(this.id));
        }
    }
}
 
// 领域服务
@service
public class orderservice {
    public void cancelorder(order order) {
        // 复杂业务逻辑
        if (order.iscancelable()) {
            order.setstatus("cancelled");
            orderrepository.save(order);
        }
    }
}

// 传统贫血模型 vs ddd充血模型

// ❌ 贫血模型（不推荐）
public class order {
    private long id;
    private bigdecimal amount;
    // 只有getter/setter
}

public class orderservice {
    public void calculatediscount(order order) {
        // 业务逻辑在service中
    }
}

// ✅ ddd充血模型（推荐）
public class order {
    private long id;
    private bigdecimal amount;
    private list<orderitem> items;
    
    // 业务逻辑在领域对象中
    public bigdecimal calculatediscount() {
        // 折扣计算逻辑
        return this.amount.multiply(getdiscountrate());
    }
    
    private bigdecimal getdiscountrate() {
        // 领域规则
        if (amount.compareto(new bigdecimal("1000")) > 0) {
            return new bigdecimal("0.9");
        }
        return bigdecimal.one;
    }
}

// 典型ddd分层结构
├── application/    // 应用层 - 用例协调
├── domain/         // 领域层 - 业务核心
├── infrastructure/ // 基础设施层 - 技术实现
└── interfaces/     // 接口层 - 对外暴露

public class order implements entity<order> {
    private orderid id;  // 值对象作为标识
    private money totalamount;
    private orderstatus status;
    
    // 通过标识判断相等性
    @override
    public boolean equals(object obj) {
        if (this == obj) return true;
        if (obj == null || getclass() != obj.getclass()) return false;
        order order = (order) obj;
        return id.equals(order.id);
    }
    
    // 业务方法
    public void cancel() {
        if (!status.cancancel()) {
            throw new illegalstateexception("订单无法取消");
        }
        this.status = orderstatus.cancelled;
    }
}

public class money implements valueobject {
    private final bigdecimal amount;
    private final currency currency;
    
    public money(bigdecimal amount, currency currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    // 值对象基于所有属性判断相等性
    @override
    public boolean equals(object obj) {
        if (this == obj) return true;
        if (obj == null || getclass() != obj.getclass()) return false;
        money money = (money) obj;
        return amount.compareto(money.amount) == 0 && 
               currency.equals(money.currency);
    }
    
    // 不可变操作
    public money add(money other) {
        if (!currency.equals(other.currency)) {
            throw new illegalargumentexception("货币类型不匹配");
        }
        return new money(amount.add(other.amount), currency);
    }
}

public class order implements aggregateroot {
    private orderid id;
    private list<orderitem> items;  // 内部实体
    private customerid customerid;
    
    // 聚合根负责维护完整性
    public void additem(product product, int quantity) {
        if (quantity <= 0) {
            throw new illegalargumentexception("数量必须大于0");
        }
        
        orderitem newitem = new orderitem(product.getid(), quantity, product.getprice());
        items.add(newitem);
        recalculatetotal();
    }
    
    // 外部只能通过聚合根访问内部对象
    public list<orderitem> getitems() {
        return collections.unmodifiablelist(items);
    }
}

public class ordercalculationservice {
    
    // 处理不适合放在实体中的跨聚合业务逻辑
    public discount calculatebestdiscount(order order, customer customer, list<promotion> promotions) {
        // 复杂的折扣计算逻辑
        return promotions.stream()
            .filter(p -> p.isapplicable(order, customer))
            .map(p -> p.calculatediscount(order))
            .max(comparator.comparing(discount::getamount))
            .orelse(discount.none);
    }
}

// 领域层定义接口
public interface orderrepository {
    order findbyid(orderid id);
    void save(order order);
    list<order> findbycustomerid(customerid customerid);
}

// 基础设施层实现
@repository
public class orderrepositoryimpl implements orderrepository {
    @autowired
    private orderjparepository jparepository;
    
    @override
    public order findbyid(orderid id) {
        orderentity entity = jparepository.findbyid(id.getvalue())
            .orelsethrow(() -> new ordernotfoundexception(id));
        return ordermapper.todomain(entity);
    }
}

com.example.ordermanagement
├── application
│   ├── command
│   ├── query
│   └── service
├── domain
│   ├── model
│   ├── service
│   ├── repository
│   └── exception
├── infrastructure
│   ├── persistence
│   ├── external
│   └── config
└── interfaces
    ├── rest
    ├── dto
    └── mapper

// 自定义注解明确ddd角色
@target(elementtype.type)
@retention(retentionpolicy.runtime)
public @interface domainentity {
}

@target(elementtype.type)
@retention(retentionpolicy.runtime)
public @interface domainservice {
}

@domainentity
public class order {
    // 领域实体
}

@domainservice  
public class ordervalidationservice {
    // 领域服务
}