【面向对象】DDD（二）：充血模型 DDD 开发模式代码示例

ゝ一世哀愁。 2023-01-14 02:56 142阅读 0赞

## 1.基于贫血模型的传统开发模式 ##

// BO，不包含业务逻辑
    // 虚拟钱包
    public class VirtualWalletBo {
        
        // 省略 getter/setter/constructor 方法 
        private Long id;   
        private Long createTime; 
        private BigDecimal balance;
    }
    
    // Service
    public class VirtualWalletService {
         
        // 通过构造函数或者 IOC 框架注入  
        private VirtualWalletRepository walletRepo;  
        private VirtualWalletTransactionRepository transactionRepo;  
        
        public VirtualWalletBo getVirtualWallet(Long walletId) {
          
            VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId);
            VirtualWalletBo walletBo = convert(walletEntity);   
            return walletBo;
        }    
        public BigDecimal getBalance(Long walletId) {
           
            return virtualWalletRepo.getBalance(walletId); 
        }   
        public void debit(Long walletId, BigDecimal amount) {
         
            VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId);   
            BigDecimal balance = walletEntity.getBalance();   
            if (balance.compareTo(amount) < 0) {
             
                throw new NoSufficientBalanceException(...); 
            }    
            walletRepo.updateBalance(walletId, balance.subtract(amount));
        }    
        public void credit(Long walletId, BigDecimal amount) {
          
            VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId); 
            BigDecimal balance = walletEntity.getBalance();    
            walletRepo.updateBalance(walletId, balance.add(amount)); 
        }    
        public void transfer(Long fromWalletId, Long toWalletId, BigDecimal amount) {
          
            VirtualWalletTransactionEntity transactionEntity = new VirtualWalletTransac
            transactionEntity.setAmount(amount);   
            transactionEntity.setCreateTime(System.currentTimeMillis());   
            transactionEntity.setFromWalletId(fromWalletId);  
            transactionEntity.setToWalletId(toWalletId);   
            transactionEntity.setStatus(Status.TO_BE_EXECUTED);
            Long transactionId = transactionRepo.saveTransaction(transactionEntity);   
            try {
             
                debit(fromWalletId, amount);   
                credit(toWalletId, amount);  
            } catch (InsufficientBalanceException e) {
             
                transactionRepo.updateStatus(transactionId, Status.CLOSED);    
                ...rethrow exception e...   
            } catch (Exception e) {
            
                transactionRepo.updateStatus(transactionId, Status.FAILED);  
                ...rethrow exception e...  
            }    
            transactionRepo.updateStatus(transactionId, Status.EXECUTED);  
        } 
    }

## 2.基于充血模型的DDD开发模式 ##

// 虚拟钱包
    public class VirtualWallet {
         
        // Domain 领域模型 (充血模型) 
        private Long id; 
        private Long createTime = System.currentTimeMillis();;  
        private BigDecimal balance = BigDecimal.ZERO;    
        public VirtualWallet(Long preAllocatedId) {
        
             this.id = preAllocatedId;  
        }    
        public BigDecimal balance() {
         
            return this.balance; 
        }    
        public void debit(BigDecimal amount) {
          
            if (this.balance.compareTo(amount) < 0) {
           
                throw new InsufficientBalanceException(...); 
            }    
            this.balance.subtract(amount);
        }   
        public void credit(BigDecimal amount) {
           
            if (amount.compareTo(BigDecimal.ZERO) < 0) {
          
                throw new InvalidAmountException(...);   
            }   
            this.balance.add(amount); 
        } 
    }
    
    public class VirtualWalletService {
         
        // 通过构造函数或者 IOC 框架注入  
        private VirtualWalletRepository walletRepo;  
        private VirtualWalletTransactionRepository transactionRepo;  
        
        public VirtualWallet getVirtualWallet(Long walletId) {
           
            VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId);
            VirtualWallet wallet = convert(walletEntity);   
            return wallet; 
        }    
        public BigDecimal getBalance(Long walletId) {
           
            return virtualWalletRepo.getBalance(walletId); 
        }   
        public void debit(Long walletId, BigDecimal amount) {
          
            VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId);
            VirtualWallet wallet = convert(walletEntity);    
            wallet.debit(amount);    
            walletRepo.updateBalance(walletId, wallet.balance());  
        }    
        public void credit(Long walletId, BigDecimal amount) {
        
            VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId); 
            VirtualWallet wallet = convert(walletEntity);   
            wallet.credit(amount);    
            walletRepo.updateBalance(walletId, wallet.balance()); 
        }    
        public void transfer(Long fromWalletId, Long toWalletId, BigDecimal amount) {
        
             //... 跟基于贫血模型的传统开发模式的代码一样...  
        } 
    }

看了上面的代码，你可能会说，领域模型 VirtualWallet 类很单薄，包含的业务逻辑很简单。相对于原来的贫血模型的设计思路，这种充血模型的设计思路，貌似并没有太大优势。 你说得没错！这也是大部分业务系统都使用基于贫血模型开发的原因。

不过，如果虚拟钱包系统需要支持更复杂的业务逻辑，那充血模型的优势就显现出来了。

比如，我们要支持透支一定额度和冻结部分余额的功能。这个时候，我们重新来看一下 VirtualWallet 类的实现代码。

public class VirtualWallet {
          
        private Long id; 
        private Long createTime = System.currentTimeMillis();; 
        private BigDecimal balance = BigDecimal.ZERO; 
        private boolean isAllowedOverdraft = true;  
        private BigDecimal overdraftAmount = BigDecimal.ZERO;
        private BigDecimal frozenAmount = BigDecimal.ZERO; 
        public VirtualWallet(Long preAllocatedId) {
         
            this.id = preAllocatedId; 
        }   
        public void freeze(BigDecimal amount) {
        
            ... 
        }
        public void unfreeze(BigDecimal amount) 
        {
         
            ...
        }  
        public void increaseOverdraftAmount(BigDecimal amount) {
         
            ... 
        }  
        public void decreaseOverdraftAmount(BigDecimal amount) {
        
            ...
        } 
        public void closeOverdraft() {
        
            ... 
        }  
        public void openOverdraft() {
         
            ... 
        }   
        public BigDecimal balance() {
         
            return this.balance;
        }    
        public BigDecimal getAvaliableBalance() {
         
            BigDecimal totalAvaliableBalance = this.balance.subtract(this.frozenAmount) 
                if (isAllowedOverdraft) {
         
                    totalAvaliableBalance += this.overdraftAmount; 
                }   
            return totalAvaliableBalance;
        }   
        public void debit(BigDecimal amount) {
        
            BigDecimal totalAvaliableBalance = getAvaliableBalance(); 
            if (totoalAvaliableBalance.compareTo(amount) < 0) {
         	
                 throw new InsufficientBalanceException(...);   
            }   
            this.balance.subtract(amount); 
        }   
        public void credit(BigDecimal amount) {
            
            if (amount.compareTo(BigDecimal.ZERO) < 0) {
            
                throw new InvalidAmountException(...);  
            }    
            this.balance.add(amount);
        } 
    }

领域模型 VirtualWallet 类添加了简单的冻结和透支逻辑之后，功能看起来就丰富了很多， 代码也没那么单薄了。如果功能继续演进，我们可以增加更加细化的冻结策略、透支策略、 支持钱包账号（VirtualWallet id 字段）自动生成的逻辑（不是通过构造函数经外部传入 ID，而是通过分布式 ID 生成算法来自动生成 ID）等等。

VirtualWallet 类的业务逻辑会变得越来越复杂，也就很值得设计成充血模型了。