> 欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java_front」一起交流学习
# 1 整体思想计算机领域有一句话：计算机中任何问题都可通过增加一个虚拟层解决。这句体现了分层思想重要性，分层思想同样适用于Java工程架构。分层优点是每层只专注本层工作，可以类比设计模式单一职责原则，或者经济学比较优势原理，每层只做本层最擅长的事情。分层缺点是层之间通信时，需要通过适配器，翻译成本层或者下层可以理解的信息，通信成本有所增加。我认为工程分层需要从六个维度思考： #### (1) 单一每层只处理一类事情，满足单一职责原则 #### (2) 降噪信息在每一层进行传输，满足最小知识原则，只向下层传输必要信息 #### (3) 适配每层都需要一个适配器，翻译信息为本层或者下层可以理解的信息 #### (4) 纵向纵向做隔离，同一个领域内业务要在本领域内聚 #### (5) 横向横向做编排，应用层聚合多个领域进行业务编排 #### (6) 数据数据对象尽量纯净，尽量使用基本类型
## 1.2 九层结构 SpringBoot工程可以分成九层： - 工具层：util - 整合层：integration - 基础层：infrastructure - 领域层：domain - 应用层：application - 门面层：facade - 客户端：client - 控制层：controller - 启动层：boot
![SpringBoot九层结构_DDD.jpg](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/977b972ab0e442d09bd8387723d09884~tplv-k3u1fbpfcp-watermark.image?)
## 1.3 微服务与九层结构微服务和九层架构表述的是不同维度概念。微服务重点描述系统与系统之间交互关系，九层架构重点描述一个工程不同模块之间交互关系，这一点不要混淆。微服务架构设计中通常分为前台、中台、后台：
![变化多端_2.jpg](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3128029e825141db8183c4dee0e921d8~tplv-k3u1fbpfcp-watermark.image?)
第一点上图所有应用均可采用九层结构。第二点中台应用承载核心逻辑，暴露核心接口，中台并不要理解所有端数据结构，而是通过client接口暴露相对稳定的数据。第三点针对面向B端、面向C端、面向运营三种端，各自拆分出一个应用，在此应用中进行转换、适配和裁剪，并且处理各自业务。第四点什么是大中台、小前台思想？中台提供稳定服务，前台提供灵活入口。第五点如果后续要做秒杀系统，那么也可以理解其为一个前台应用（seckill-front）聚合各种中台接口。
# 2 分层详解第一步创建项目： ```xml user-demo-service -user-demo-service-application -user-demo-service-boot -user-demo-service-client -user-demo-service-controller -user-demo-service-domain -user-demo-service-facade -user-demo-service-infrastructure -user-demo-service-integration -user-demo-service-util ```
## 2.1 util 工具层承载工具代码不依赖本项目其它模块只依赖一些通用工具包 ```xml user-demo-service-util -/src/main/java -date -DateUtil.java -json -JsonUtil.java -validate -BizValidator.java ```
## 2.2 infrastructure 基础层承载数据访问和entity 同时承载基础服务（ES、Redis、MQ）
### 2.2.1 项目结构 ```xml user-demo-service-infrastructure -/src/main/java -base -service -redis -RedisService.java -mq -ProducerService.java -player -entity -PlayerEntity.java -mapper -PlayerEntityMapper.java -game -entity -GameEntity.java -mapper -GameEntityMapper.java -/src/main/resources -mybatis -sqlmappers -gameEntityMapper.xml -playerEntityMapper.xml ```
### 2.2.2 本项目依赖 - util
### 2.2.3 核心代码创建运动员数据表： ```text CREATE TABLE `player` ( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键', `player_id` varchar(256) NOT NULL COMMENT '运动员编号', `player_name` varchar(256) NOT NULL COMMENT '运动员名称', `height` int(11) NOT NULL COMMENT '身高', `weight` int(11) NOT NULL COMMENT '体重', `game_performance` text COMMENT '最近一场比赛表现', `creator` varchar(256) NOT NULL COMMENT '创建人', `updator` varchar(256) NOT NULL COMMENT '修改人', `create_time` datetime NOT NULL COMMENT '创建时间', `update_time` datetime NOT NULL COMMENT '修改时间', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 ```
运动员实体对象，gamePerformance字段作为string保存在数据库，体现了数据层尽量纯净，不要整合过多业务，解析任务应该放在业务层： ```java public class PlayerEntity { private Long id; private String playerId; private String playerName; private Integer height; private Integer weight; private String creator; private String updator; private Date createTime; private Date updateTime; private String gamePerformance; } ```
运动员Mapper对象： ```java @Repository public interface PlayerEntityMapper { int insert(PlayerEntity record); int updateById(PlayerEntity record); PlayerEntity selectById(@Param("playerId") String playerId); } ```
## 2.3 integration 本层调用外部服务，转换外部DTO成为本项目可以理解对象。
### 2.3.1 项目结构本项目调用用户中心服务： ```xml user-demo-service-integration -/src/main/java -user -adapter -UserClientAdapter.java -proxy -UserClientProxy.java -vo // 本项目对象 -UserSimpleAddressVO.java -UserSimpleContactVO.java -UserSimpleBaseInfoVO.java ```
### 2.3.2 本项目依赖 - util
### 2.3.3 核心代码 #### (1) 外部服务 ```java // 外部对象 public class UserInfoClientDTO implements Serializable { private String id; private String name; private Date createTime; private Date updateTime; private String mobile; private String cityCode; private String addressDetail; } // 外部服务 public class UserClientService { // RPC public UserInfoClientDTO getUserInfo(String userId) { UserInfoClientDTO userInfo = new UserInfoClientDTO(); userInfo.setId(userId); userInfo.setName(userId); userInfo.setCreateTime(DateUtil.now()); userInfo.setUpdateTime(DateUtil.now()); userInfo.setMobile("test-mobile"); userInfo.setCityCode("test-city-code"); userInfo.setAddressDetail("test-address-detail"); return userInfo; } } ```
#### (2) 本项目对象 ```java // 基本对象 public class UserBaseInfoVO { private UserContactVO contactInfo; private UserAddressVO addressInfo; } // 地址值对象 public class UserAddressVO { private String cityCode; private String addressDetail; } // 联系方式值对象 public class UserContactVO { private String mobile; } ```
#### (3) 适配器 ```java public class UserClientAdapter { public UserBaseInfoVO convert(UserInfoClientDTO userInfo) { // 基础信息 UserBaseInfoVO userBaseInfo = new UserBaseInfoVO(); // 联系方式 UserContactVO contactVO = new UserContactVO(); contactVO.setMobile(userInfo.getMobile()); userBaseInfo.setContactInfo(contactVO); // 地址信息 UserAddressVO addressVO = new UserAddressVO(); addressVO.setCityCode(userInfo.getCityCode()); addressVO.setAddressDetail(userInfo.getAddressDetail()); userBaseInfo.setAddressInfo(addressVO); return userBaseInfo; } } ```
#### (4) 调用外部服务 ```java public class UserClientProxy { @Resource private UserClientService userClientService; @Resource private UserClientAdapter userIntegrationAdapter; // 查询用户 public UserBaseInfoVO getUserInfo(String userId) { UserInfoClientDTO user = userClientService.getUserInfo(userId); UserBaseInfoVO result = userIntegrationAdapter.convert(user); return result; } } ```
## 2.4 domain ### 2.4.1 概念说明通过三组对比理解领域层： - 领域对象 VS 数据对象 - 领域对象 VS 业务对象 - 领域层 VS 应用层
#### (1) 领域对象 VS 数据对象数据对象使用基本类型保持纯净： ```java public class PlayerEntity { private Long id; private String playerId; private String playerName; private Integer height; private Integer weight; private String creator; private String updator; private Date createTime; private Date updateTime; private String gamePerformance; } ```
领域对象需要体现业务含义： ```java public class PlayerQueryResultDomain { private String playerId; private String playerName; private Integer height; private Integer weight; private GamePerformanceVO gamePerformance; } public class GamePerformanceVO { // 跑动距离 private Double runDistance; // 传球成功率 private Double passSuccess; // 进球数 private Integer scoreNum; } ```
#### (2) 领域对象 VS 业务对象业务对象同样会体现业务，领域对象和业务对象有什么不同？最大不同是领域对象采用充血模型聚合业务。运动员新增业务对象： ```java public class PlayerCreateBO { private String playerName; private Integer height; private Integer weight; private GamePerformanceVO gamePerformance; private MaintainCreateVO maintainInfo; } ```
运动员新增领域对象： ```java public class PlayerCreateDomain implements BizValidator { private String playerName; private Integer height; private Integer weight; private GamePerformanceVO gamePerformance; private MaintainCreateVO maintainInfo; @Override public void validate() { if (StringUtils.isEmpty(playerName)) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == height) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (height > 300) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == weight) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null != gamePerformance) { gamePerformance.validate(); } if (null == maintainInfo) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } maintainInfo.validate(); } } ```
#### (3) 领域层 VS 应用层第一个区别：领域层关注纵向，应用层关注横向。领域层纵向做隔离，本领域业务行为要在本领域内处理完。应用层横向做编排，聚合和编排领域服务。第二个区别：应用层可以更加灵活组合不同领域业务，并且可以增加流控、监控、日志、权限，分布式锁，相较于领域层功能更为丰富。
### 2.4.2 项目结构 ```xml user-demo-service-domain -/src/main/java -base -domain -BaseDomain.java -event -BaseEvent.java -vo -BaseVO.java -MaintainCreateVO.java -MaintainUpdateVO.java -player -adapter -PlayerDomainAdapter.java -domain -PlayerCreateDomain.java // 领域对象 -PlayerUpdateDomain.java -PlayerQueryResultDomain.java -event // 领域事件 -PlayerUpdateEvent.java -PlayerMessageSender.java -service // 领域服务 -PlayerDomainService.java -vo // 值对象 -GamePerformanceVO.java -game -adapter -GameDomainAdapter.java -domain -GameCreateDomain.java -GameUpdateDomain.java -GameQueryResultDomain.java -service -GameDomainService.java ```
### 2.4.3 本项目依赖 - util - client 领域对象进行业务校验，所以需要依赖client模块： - BizException - ErrorCodeBizEnum
### 2.4.4 核心代码 ```java // 修改领域对象 public class PlayerUpdateDomain extends BaseDomain implements BizValidator { private String playerId; private String playerName; private Integer height; private Integer weight; private String updator; private Date updatetime; private GamePerformanceVO gamePerformance; private MaintainUpdateVO maintainInfo; @Override public void validate() { if (StringUtils.isEmpty(playerId)) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (StringUtils.isEmpty(playerName)) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == height) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (height > 300) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == weight) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null != gamePerformance) { gamePerformance.validate(); } if (null == maintainInfo) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } maintainInfo.validate(); } } // 比赛表现值对象 public class GamePerformanceVO implements BizValidator { // 跑动距离 private Double runDistance; // 传球成功率 private Double passSuccess; // 进球数 private Integer scoreNum; @Override public void validate() { if (null == runDistance) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == passSuccess) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (Double.compare(passSuccess, 100) > 0) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == runDistance) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == scoreNum) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } } } // 修改人值对象 public class MaintainUpdateVO implements BizValidator { // 修改人 private String updator; // 修改时间 private Date updateTime; @Override public void validate() { if (null == updator) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } if (null == updateTime) { throw new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT); } } } // 领域服务 public class PlayerDomainService { @Resource private UserClientProxy userClientProxy; @Resource private PlayerRepository playerEntityMapper; @Resource private PlayerDomainAdapter playerDomainAdapter; @Resource private PlayerMessageSender playerMessageSender; public boolean updatePlayer(PlayerUpdateDomain player) { AssertUtil.notNull(player, new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT)); player.validate(); // 更新运动员信息 PlayerEntity entity = playerDomainAdapter.convertUpdate(player); playerEntityMapper.updateById(entity); // 发送更新消息 playerMessageSender.sendPlayerUpdatemessage(player); // 查询用户信息 UserSimpleBaseInfoVO userInfo = userClientProxy.getUserInfo(player.getMaintainInfo().getUpdator()); log.info("updatePlayer maintainInfo={}", JacksonUtil.bean2Json(userInfo)); return true; } } ```
## 2.5 application 本层关注横向维度聚合领域服务，引出一种新对象称为聚合对象。因为本层需要聚合多个维度，所以需要通过聚合对象聚合多领域属性，例如提交订单需要聚合商品、物流、优惠券多个领域。 ```java // 订单提交聚合对象 public class OrderSubmitAgg { // userId private String userId; // skuId private String skuId; // 购买量 private Integer quantity; // 地址信息 private String addressId; // 可用优惠券 private String couponId; } // 订单应用服务 public class OrderApplicationService { @Resource private OrderDomainService orderDomainService; @Resource private CouponDomainService couponDomainService; @Resource private ProductDomainService productDomainService; // 提交订单 public String submitOrder(OrderSubmitAgg orderSumbitAgg) { // 订单编号 String orderId = generateOrderId(); // 商品校验 productDomainService.queryBySkuId(orderSumbitAgg.getSkuId()); // 扣减库存 productDomainService.subStock(orderSumbitAgg.getStockId(), orderSumbitAgg.getQuantity()); // 优惠券校验 couponDomainService.validate(userId, couponId); // ...... // 创建订单 OrderCreateDomain domain = OrderApplicationAdapter.convert(orderSubmitAgg); orderDomainService.createOrder(domain); return orderId; } } ```
### 2.5.1 项目结构 ```xml user-demo-service-application -/src/main/java -player -adapter -PlayerApplicationAdapter.java -agg -PlayerCreateAgg.java -PlayerUpdateAgg.java -service -PlayerApplicationService.java -game -listener -PlayerUpdateListener.java // 监听运动员更新事件 ```
### 2.5.2 本项目依赖 - util - domain - integration - infrastructure
### 2.5.3 核心代码本项目领域事件交互使用EventBus框架： ```java // 运动员应用服务 public class PlayerApplicationService { @Resource private LogDomainService logDomainService; @Resource private PlayerDomainService playerDomainService; @Resource private PlayerApplicationAdapter playerApplicationAdapter; public boolean updatePlayer(PlayerUpdateAgg agg) { // 运动员领域 boolean result = playerDomainService.updatePlayer(agg.getPlayer()); // 日志领域 LogReportDomain logDomain = playerApplicationAdapter.convert(agg.getPlayer().getPlayerName()); logDomainService.log(logDomain); return result; } } // 比赛领域监听运动员变更事件 public class PlayerUpdateListener { @Resource private GameDomainService gameDomainService; @PostConstruct public void init() { EventBusManager.register(this); } @Subscribe public void listen(PlayerUpdateEvent event) { // 更新比赛计划 gameDomainService.updateGameSchedule(); } } ```
## 2.6 facade + client 设计模式中有一种Facade模式，称为门面模式或者外观模式。这种模式提供一个简洁对外语义，屏蔽内部系统复杂性。 client承载数据对外传输对象DTO，facade承载对外服务，必须满足最小知识原则，无关信息不必对外透出。这样做有两个优点： - 简洁性：对外服务语义明确简洁 - 安全性：敏感字段不能对外透出
### 2.6.1 项目结构 #### (1) client ```xml user-demo-service-client -/src/main/java -base -dto -BaseDTO.java -error -BizException.java -BizErrorCode.java -event -BaseEventDTO.java -result -ResultDTO.java -player -dto -PlayerCreateDTO.java -PlayerQueryResultDTO.java -PlayerUpdateDTO.java -enums -PlayerMessageTypeEnum.java -service -PlayerClientService.java ```
#### (2) facade ```xml user-demo-service-facade -/src/main/java -player -adapter -PlayerFacadeAdapter.java -impl -PlayerClientServiceImpl.java -game -adapter -GameFacadeAdapter.java -impl -GameClientServiceImpl.java ```
### 2.6.2 本项目依赖 client不依赖本项目其它模块，这一点非常重要：因为client会被外部引用，必须保证本层简洁和安全。 facade依赖本项目三个模块： - domain - client - application
### 2.6.3 核心代码 #### (1) DTO 以查询运动员信息为例，查询结果DTO只封装强业务字段，运动员ID、创建时间、修改时间等业务不强字段无须透出： ```java public class PlayerQueryResultDTO implements Serializable { private String playerName; private Integer height; private Integer weight; private GamePerformanceDTO gamePerformanceDTO; } ```
#### (2) 客户端服务 ```java public interface PlayerClientService { public ResultDTO queryById(String playerId); } ```
#### (3) 适配器 ```java public class PlayerFacadeAdapter { // domain -> dto public PlayerQueryResultDTO convertQuery(PlayerQueryResultDomain domain) { if (null == domain) { return null; } PlayerQueryResultDTO result = new PlayerQueryResultDTO(); result.setPlayerId(domain.getPlayerId()); result.setPlayerName(domain.getPlayerName()); result.setHeight(domain.getHeight()); result.setWeight(domain.getWeight()); if (null != domain.getGamePerformance()) { GamePerformanceDTO performance = convertGamePerformance(domain.getGamePerformance()); result.setGamePerformanceDTO(performance); } return result; } } ```
#### (4) 服务实现本层可以引用applicationService，也可以引用domainService，因为对于类似查询等简单业务场景，没有多领域聚合，可以直接使用领域服务。 ```java public class PlayerClientServiceImpl implements PlayerClientService { @Resource private PlayerDomainService playerDomainService; @Resource private PlayerFacadeAdapter playerFacadeAdapter; @Override public ResultDTO queryById(String playerId) { PlayerQueryResultDomain resultDomain = playerDomainService.queryPlayerById(playerId); if (null == resultDomain) { return ResultCommonDTO.success(); } PlayerQueryResultDTO result = playerFacadeAdapter.convertQuery(resultDomain); return ResultCommonDTO.success(result); } } ```
## 2.7 controller facade服务实现可以作为RPC提供服务，controller则作为本项目HTTP接口提供服务，供前端调用。 controller需要注意HTTP相关特性，敏感信息例如登陆用户ID不能依赖前端传递，登陆后前端会在请求头带一个登陆用户信息，服务端需要从请求头中获取并解析。
### 2.7.1 项目结构 ```xml user-demo-service-controller -/src/main/java -controller -player -PlayerController.java -game -GameController.java ```
### 2.7.2 本项目依赖 - facade
### 2.7.3 核心代码 ```java @RestController @RequestMapping("/player") public class PlayerController { @Resource private PlayerClientService playerClientService; @PostMapping("/add") public ResultDTO add(@RequestHeader("test-login-info") String loginUserId, @RequestBody PlayerCreateDTO dto) { dto.setCreator(loginUserId); ResultCommonDTO resultDTO = playerClientService.addPlayer(dto); return resultDTO; } @PostMapping("/update") public ResultDTO update(@RequestHeader("test-login-info") String loginUserId, @RequestBody PlayerUpdateDTO dto) { dto.setUpdator(loginUserId); ResultCommonDTO resultDTO = playerClientService.updatePlayer(dto); return resultDTO; } @GetMapping("/{playerId}/query") public ResultDTO queryById(@RequestHeader("test-login-info") String loginUserId, @PathVariable("playerId") String playerId) { ResultCommonDTO resultDTO = playerClientService.queryById(playerId); return resultDTO; } } ```
## 2.8 boot boot作为启动层承载启动入口
### 2.8.1 项目结构所有模块代码均必须属于com.user.demo.service子路径： ```xml user-demo-service-boot -/src/main/java -com.user.demo.service -MainApplication.java ```
### 2.8.2 依赖本项目 - 所有模块
### 2.8.3 核心代码 ```java @MapperScan("com.user.demo.service.infrastructure.*.mapper") @SpringBootApplication public class MainApplication { public static void main(final String[] args) { SpringApplication.run(MainApplication.class, args); } } ```
# 3 文章总结 ## 3.1 六个维度 #### (1) 单一每层只处理一类事情，util只承载工具对象，integration只处理外部服务，每层职责单一且清晰 #### (2) 降噪如无必要勿增实体，例如查询结果DTO只透出最关键字段，例如运动员ID、创建时间、修改时间等业务不强字段无须透出 #### (3) 适配 service、facade、intergration层都存在适配器，翻译信息为本层或者下层可以理解的信息 #### (4) 纵向 domain service内聚本领域业务 #### (5) 横向 application service编排多个领域业务 #### (6) 数据数据对象要纯净，尽量使用基本类型
## 3.2 微服务与九层结构微服务和九层结构表述的是不同维度概念。微服务重点描述系统与系统之间交互关系，九层结构重点描述一个工程不同模块之间交互关系。
> 欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java_front」一起交流学习