领域驱动设计——项目分层与落地
什么是Evans DDD
2004年Eric Evans 发表Domain-Driven Design –Tackling Complexity in the Heart of Software （领域驱动设计 ）简称Evans DDD。
领域驱动设计事实上是针对OOAD的一个扩展和延伸，DDD基于面向对象分析与设计技术，对技术架构进行了分层规划，同时对每个类进行了策略和类型的划分。
领域模型是领域驱动的核心。采用DDD的设计思想，业务逻辑不再集中在几个大型的类上，而是由大量相对小的领域对象(类)组成，这些类具备自己的状态和行为，每个类是相对完整的独立体，并与现实领域的业务对象映射。领域模型就是由这样许多的细粒度的类组成。基于领域驱动的设计，保证了系统的可维护性、扩展性和复用性，在处理复杂业务逻辑方面有着先天的优势。
分析设计发展的三个阶段
第一阶段：围绕数据库的驱动设计，新项目总是从设计数据库及其字段开始。
过去软件系统分析设计总是从数据库开始，这种围绕数据库分析设计的缺点非常明显：
1.分析方面：不能迅速有效全面分析需求。
2.设计方面：导致过程化设计编程，丧失了面向对象设计的优点。
3.运行方面：导致软件运行时负载集中在数据库端，系统性能难于扩展，闲置了中间件J2EE服务器处理性能。
对象和关系数据库存在阻抗，本身是矛盾竞争的。
第二阶段：面向对象的分析设计方法诞生后，有了专门的分析和设计阶段之分，但是分析阶段和设计阶段是断裂的。
第二阶段比第一阶段进步很多，开始采取面向对象的方法来分析设计需求。
分析人员的职责：是负责从需求领域中收集基本概念。面向需求。
设计人员的职责：必须指明一组能北项目中适应编程工具构造的组件，这些组件必须能够在目标环境中有效执行，并能够正确解决应用程序出现的问题
第三阶段：融合了分析阶段和设计阶段的领域驱动设计（Evans: DDD）。
分析模型会有知识不断消化的过程，但在编码时这些知识会被遗弃。
开发人员被迫为设计进行新的抽象，那么分析人员嵌入模型中知识不能保留和重新发现。
分析模型很多重要发现更改往往出现在设计实现过程，预先的模型可能深入研究无关主题，忽视重要主题。
什么是领域模型 Domain Model：
在软件工程中，领域模型是包含属性和行为的业务模型。
领域模型只有业务（真实世界的概念），没有技术。只表达需求真实世界模型，和软件架构技术无关。在项目中，领域层为整个项目的核心，其他的都作为辅助层。
举一个机器人的例子：
机器人的领域模型：
分层领域:
将领域概念和其他软件技术相关概念分离，可以避免混淆、在系统庞大中失去对领域的把握。领域驱动设计的分层架构和构成要素，这部分内容在Eric Evans的书中有非常详尽的描述:
表现层：负责显示，解析用户命令
应用层：指挥领域对象实现功能，必须保持简练，不是核心。
领域层：核心 业务概念
基础层：与软件技术相关。
拿一个航运系统举例子：
项目的分层逻辑：
表现层：接受用户输入（屏幕绘制 ）
向用户显示信息 （显示结果）
领域层: 执行业务逻辑 （查询所有城市 城市和货物关联）
基础层: 访问数据库（查询数据库 提交数据库更改网络通信）
不要将UI 数据库和其他支持代码直接写到业务对象中，虽然简单容易，但是拓展困难，难于自动化测试。
分层的优点：
每个层都是内聚的，并且只依赖它的下层，为了实现各层的最大解耦，IOC/DI容器是当前Java业务层的最好选择 。
将所有与需求领域有关的代码集中在领域层，并与用户UI层 应用层和基础层分离。领域对象就可以重点关注表达领域模型，不关心自己的显示存储和管理应用任务等事情。
适合分布式部署，提升性能，高可伸缩性。
领域模型的切割：
领域驱动设计除了对系统架构进行了分层描述，还对对象（Object）做了明确的职责和策略划分：
1、实体（Entities）：具备唯一ID，能够被持久化，具备业务逻辑，对应现实世界业务对象。
2、值对象（Value objects）：不具有唯一ID，由对象的属性描述，一般为内存中的临时对象，可以用来传递参数或对实体进行补充描述。
3、工厂（Factories）：主要用来创建实体，目前架构实践中一般采用IOC容器来实现工厂的功能。
4、仓库（Repositories）：用来管理实体的集合，封装持久化框架。
5、服务（Services）：为上层建筑提供可操作的接口，负责对领域对象进行调度和封装，同时可以对外提供各种形式的服务。
领域驱动设计实践:
基于分布式的DDD项目分层格式：
如果开发者是用maven做的项目管理，给大家推荐一个十分实用的多模块项目结构，模块的分层和依赖关系如下：
基于rpc的DDD项目分层格式：
我们用这个分层格式实现一个token获取与token验证的服务，我们可以将token作为一个领域。
TokenModel 作为实体对象
TokenRule作为值对象
将TokenModel 中的属性与行为合并为TokenDomain作为领域对象
项目结构：
应用层 Controller代码：
@Controller
@RequestMapping("/token")
public class TokenController {
@Autowired
private TokenService tokenService;
private static final Gson gson = new Gson();
@RequestMapping("/apply/{bizCode}/{bizId}")
@ResponseBody
public String apply(@PathVariable String bizCode, @PathVariable String bizId){
TokenCodeRule rule = new TokenCodeRule();
rule.setBizCode(bizCode);
rule.setBizId(bizId);
rule.setTimeout(100);
TokenModel tokenModel = tokenService.applyCode(rule);
return gson.toJson(tokenModel);
}
@RequestMapping("/check/{bizCode}/{bizId}")
@ResponseBody
public boolean check(@PathVariable String bizCode, @PathVariable String bizId){
TokenCodeRule rule = new TokenCodeRule();
rule.setBizCode(bizCode);
rule.setBizId(bizId);
return tokenService.checkCode(rule);
}
}领域层 (service, domain, model, repository)：
service：
@Service("tokenService")
public class TokenServiceImpl implements TokenService {
@Autowired
private TokenDomainRepository tokenDomainRepository;
@Override
public TokenModel applyCode(TokenCodeRule rule) {
TokenDomain domain = tokenDomainRepository.findTokenDomain(rule.getBizCode(), rule.getBizId());
if(null != domain){
// 存在库中,但已经无效或者已经过期,可以使用,更改其状态以及相关信息
domain.getTokenCode().setBizCode(rule.getBizCode());
domain.getTokenCode().setBizId(rule.getBizId());
domain.getTokenCode().setGeneratedDt(System.currentTimeMillis());
domain.getTokenCode().setTimeout(rule.getTimeout());
domain.update();
}else {
// 没有存在,可以使用,并存入库中
domain = tokenDomainRepository.createTokenDomain();
domain.getTokenCode().setBizCode(rule.getBizCode());
domain.getTokenCode().setBizId(rule.getBizId());
domain.getTokenCode().setGeneratedDt(System.currentTimeMillis());
domain.getTokenCode().setTimeout(rule.getTimeout());
domain.store();
}
return domain.getTokenCode();
}
@Override
public boolean checkCode(TokenCodeRule rule) {
TokenDomain domain = tokenDomainRepository.findTokenDomain(rule.getBizCode(), rule.getBizId());
return domain.isAvaliable();
}
}
仓储repository：
@Service("tokenDomainRepository")
public class TokenDomainRepository {
@Autowired
private TokenCodeDao tokenCodeDao;
public TokenDomain createTokenDomain() {
TokenDomain domain = new TokenDomain(this);
return domain;
}
public TokenDomain findTokenDomain(String pk){
TokenModel tokenModel = this.find(pk);
if(null == tokenModel){
return null;
}
TokenDomain domain = new TokenDomain(this);
domain.fillDomain(tokenModel);
return domain;
}
public TokenDomain findTokenDomain(String bizCode, String bizId){
return findTokenDomain(this.generatePK(bizCode, bizId));
}
private String generatePK(String bizCode, String bizId) {
if (StringUtils.isBlank(bizCode) || StringUtils.isBlank(bizId)) {
return StringUtils.EMPTY;
}
return new TokenModel(bizCode, bizId).getPk();
}
public TokenModel find(String pk){
return tokenCodeDao.find(pk);
}
public boolean insert(TokenModel tokenModel){
return tokenCodeDao.insertOrUpdate(tokenModel);
}
public boolean update(TokenModel tokenModel){
return tokenCodeDao.insertOrUpdate(tokenModel);
}
public boolean remove(String pk){
return tokenCodeDao.remove(pk);
}
}领域对象：
public class TokenModel {
/**
* 存储主键
*/
protected String pk;
/**
* Token属于哪个业务或者商户Code
*/
private String bizCode;
/**
* Token所属子业务ID[比如：用户ID]
*/
private String bizId;
/**
* Token生成时间
*/
protected long generatedDt;
/**
* Token过期时间(单位:秒)
*/
protected int timeout;
public TokenModel() {
}
public TokenModel(String bizCode, String bizId) {
this.bizCode = bizCode;
this.bizId = bizId;
this.generatedDt = System.currentTimeMillis();
this.timeout = 1000;
}
public String getPk() {
if (StringUtils.isNotBlank(this.pk)) {
return this.pk;
} else if (StringUtils.isNotBlank(this.bizCode) && StringUtils.isNotBlank(this.bizId)) {
this.pk = DigestUtils.digest(new StringBuffer(this.bizCode).append("_").append(this.bizId).toString());
return this.pk;
}
return StringUtils.EMPTY;
}
public void setPk(String pk) {
this.pk = pk;
}
public long getGeneratedDt() {
return generatedDt;
}
public void setGeneratedDt(long generatedDt) {
this.generatedDt = generatedDt;
}
public int getTimeout() {
return timeout;
}
public void setTimeout(int timeout) {
this.timeout = timeout;
}
public String getBizCode() {
return bizCode;
}
public void setBizCode(String bizCode) {
this.bizCode = bizCode;
}
public String getBizId() {
return bizId;
}
public void setBizId(String bizId) {
this.bizId = bizId;
}
}
public class TokenDomain {
private TokenDomainRepository tokenDomainRepository;
protected TokenModel tokenCode = new TokenModel();
public void fillDomain(TokenModel tokenCode) {
this.tokenCode = tokenCode;
}
public TokenModel getTokenCode() {
return tokenCode;
}
public TokenDomain(TokenDomainRepository tokenDomainRepository) {
this.tokenDomainRepository = tokenDomainRepository;
}
public boolean isAvaliable(){
return this.tokenCode.getGeneratedDt() + 1000 * this.tokenCode.getTimeout() > System.currentTimeMillis();
}
/**
* 插入一条数据
*/
public void store() {
this.tokenDomainRepository.insert(this.tokenCode);
}
/**
* 更新一条数据
*/
public void update() {
this.tokenDomainRepository.update(this.tokenCode);
}
/**
* 清除记录
*/
public void remove() {
this.tokenDomainRepository.remove(this.tokenCode.getPk());
}
}
在基于rpc的项目中，我们将领域对象分成了 TokenModel，TokenDomain，因为我们需要将TokenModel作为依赖让client去引用，而TokenDomain中的一些数据库操作等是无法被依赖的，所以需要单提出来。
基础设施层：
@Component("tokenCodeDao")
public class TokenCodeDaoImpl implements TokenCodeDao{
private static final Map dbMock = new ConcurrentHashMap();
@Override
public TokenModel find(String pk) {
return dbMock.get(pk);
}
@Override
public boolean insertOrUpdate(TokenModel tokenModel) {
dbMock.put(tokenModel.getPk(), tokenModel);
return true;
}
@Override
public boolean remove(String pk) {
dbMock.remove(pk);
return true;
}
} 一个简单的DDD项目大概包括上述东西，因为互联网的应用都是基于存储的，我们将领域对象的生成模块（factory）合并到了仓储模块（repository）中。在处理复杂的业务系统时，DDD相对于传统的mvc架构具有先天的优势。大家在今后的项目开发中，不妨尝试用DDD的方式实现，时刻学习一些新的东西，在问题来临时，才能从容面对。