DDD四层架构
DDD四层架构
对实时性要求高的强一致性业务场景,可采取分布式事务。分布式事务有性能代价,在设计时需要平衡考虑业务拆分、数据一致性、性能和实现的复杂度,尽量避免分布式事务的产生。
领域事件驱动的异步方式是分布式架构常用的设计方式,可以解决非实时性场景下的数据最终一致性问题。基于消息中间件的领域事件发布和订阅,可以很好的解耦微服务。通过削峰填谷,实现读写分离、减轻数据库实时访问压力,提高业务吞吐量和业务处理能力。
DDD设计思想和方法
DDD设计思想和方法
聚合根
聚合根包括聚合根属性、关联的实体和值对象以及自身的业务行为等。通过引用实体和值对象,协调聚合内的多个实体,在聚合根类方法中完成多实体的复杂业务逻辑。
充血模型:即领域模型模式。有自己的业务行为(方法),如下充血模型中提供getDuration、addHistoryApprovalInfo等方法。
贫血模型:即事务脚本模式。只有对象属性和setter/getter。
@Data
public class Leave {
String id;
Applicant applicant;
Approver approver;
LeaveType type;
Status status;
Date startTime;
Date endTime;
long duration;
//审批领导的最大级别
int leaderMaxLevel;
ApprovalInfo currentApprovalInfo;
List<ApprovalInfo> historyApprovalInfos;
public long getDuration() {
return endTime.getTime() - startTime.getTime();
}
public Leave addHistoryApprovalInfo(ApprovalInfo approvalInfo) {
if (null == historyApprovalInfos)
historyApprovalInfos = new ArrayList<>();
this.historyApprovalInfos.add(approvalInfo);
return this;
}
public Leave create(){
this.setStatus(Status.APPROVING);
this.setStartTime(new Date());
return this;
}
public Leave agree(Approver nextApprover){
this.setStatus(Status.APPROVING);
this.setApprover(nextApprover);
return this;
}
public Leave reject(Approver approver){
this.setApprover(approver);
this.setStatus(Status.REJECTED);
this.setApprover(null);
return this;
}
public Leave finish(){
this.setApprover(null);
this.setStatus(Status.APPROVED);
this.setEndTime(new Date());
this.setDuration(this.getEndTime().getTime() - this.getStartTime().getTime());
return this;
}
}
实体
实体有自己的属性和关联的值对象。
@Data
public class ApprovalInfo {
String approvalInfoId;
Approver approver;
ApprovalType approvalType;
String msg;
long time;
}
值对象
public enum Status {
APPROVING, APPROVED, REJECTED
}
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Approver {
String personId;
String personName;
int level;
public static Approver fromPerson(Person person){
Approver approver = new Approver();
approver.setPersonId(person.getPersonId());
approver.setPersonName(person.getPersonName());
approver.setLevel(person.getRoleLevel());
return approver;
}
}
领域对象
如果一个业务行为由多个实体对象参与完成,就将该业务逻辑放在领域服务中实现。
实体方法:完成单一实体自身的业务逻辑,是相对简单的原子业务逻辑。
领域服务:由多个实体组合的相对复杂的业务逻辑。
@Service
@Slf4j
public class LeaveDomAInService {
@Autowired
EventPublisher eventPublisher;
@Autowired
ILeaveRepository iLeaveRepository;
@Autowired
LeaveFactory leaveFactory;
@Transactional
public void createLeave(Leave leave, int leaderMaxLevel, Approver approver) {
leave.setLeaderMaxLevel(leaderMaxLevel);
leave.setApprover(approver);
leave.create();
iLeaveRepository.save(leaveFactory.createLeavePO(leave));
LeaveEvent event = LeaveEvent.create(LeaveEventType.CREATE_EVENT, leave);
iLeaveRepository.saveEvent(leaveFactory.createLeaveEventPO(event));
eventPublisher.publish(event);
}
@Transactional
public void updateLeaveInfo(Leave leave) {
LeavePO po = leaveRepositoryInterface.findById(leave.getId());
if (null == po) {
throw new RuntimeException("leave不存在");
}
iLeaveRepository.save(leaveFactory.createLeavePO(leave));
}
@Transactional
public void submitApproval(Leave leave, Approver approver) {
LeaveEvent event;
if ( ApprovalType.REJECT == leave.getCurrentApprovalInfo().getApprovalType()) {
leave.reject(approver);
event = LeaveEvent.create(LeaveEventType.REJECT_EVENT, leave);
} else {
if (approver != null) {
leave.agree(approver);
event = LeaveEvent.create(LeaveEventType.AGREE_EVENT, leave);
} else {
leave.finish();
event = LeaveEvent.create(LeaveEventType.APPROVED_EVENT, leave);
}
}
leave.addHistoryApprovalInfo(leave.getCurrentApprovalInfo());
iLeaveRepository.save(leaveFactory.createLeavePO(leave));
iLeaveRepository.saveEvent(leaveFactory.createLeaveEventPO(event));
eventPublisher.publish(event);
}
public Leave getLeaveInfo(String leaveId) {
LeavePO leavePO = iLeaveRepository.findById(leaveId);
return leaveFactory.getLeave(leavePO);
}
public List<Leave> queryLeaveInfosByApplicant(String applicantId) {
List<LeavePO> leavePOList = iLeaveRepository.queryByApplicantId(applicantId);
return leavePOList.stream()
.map(leavePO -> leaveFactory.getLeave(leavePO))
.collect(Collectors.toList());
}
public List<Leave> queryLeaveInfosByApprover(String approverId) {
List<LeavePO> leavePOList = iLeaveRepository.queryByApproverId(approverId);
return leavePOList.stream()
.map(leavePO -> leaveFactory.getLeave(leavePO))
.collect(Collectors.toList());
}
}
在应用服务组合不同聚合的领域服务时,通过Id或参数传参,尽量避免领域对象传参,以减少聚合之间的耦合度。
领域事件
领域事件基类
@Data
public class DomainEvent {
String id;
Date timestamp;
String source;
String data;
}
@Service
public class EventPublisher {
public void publish(LeaveEvent event){
//send to MQ
//mq.send(event);
}
}
领域事件实体
@Data
public class LeaveEvent extends DomainEvent {
LeaveEventType leaveEventType;
public static LeaveEvent create(LeaveEventType eventType, Leave leave){
LeaveEvent event = new LeaveEvent();
event.setId(IdGenerator.nextId());
event.setLeaveEventType(eventType);
event.setTimestamp(new Date());
event.setData(JSON.toJSONString(leave));
return event;
}
}
领域事件的执行逻辑:
- 执行业务逻辑,产生领域事件。
- 调用仓储接口,完成业务数据持久化。
- 调用仓储接口,完成事件数据持久化。
- 完成领域事件发布。
仓储模式
仓储接口
public interface ILeaveRepository {
void save(LeavePO leavePO);
void saveEvent(LeaveEventPO leaveEventPO);
LeavePO findById(String id);
List<LeavePO> queryByApplicantId(String applicantId);
List<LeavePO> queryByApproverId(String approverId);
}
仓储实现
@Repository
public class LeaveRepositoryImpl implements ILeaveRepository {
@Autowired
LeaveDao leaveDao;
@Autowired
ApprovalInfoDao approvalInfoDao;
@Autowired
LeaveEventDao leaveEventDao;
public void save(LeavePO leavePO) {
leaveDao.save(leavePO);
leavePO.getHistoryApprovalInfoPOList().forEach(approvalInfoPO -> approvalInfoPO.setLeaveId(leavePO.getId()));
approvalInfoDao.saveAll(leavePO.getHistoryApprovalInfoPOList());
}
public void saveEvent(LeaveEventPO leaveEventPO){
leaveEventDao.save(leaveEventPO);
}
@Override
public LeavePO findById(String id) {
return leaveDao.findById(id)
.orElseThrow(() -> new RuntimeException("leave不存在"));
}
@Override
public List<LeavePO> queryByApplicantId(String applicantId) {
List<LeavePO> leavePOList = leaveDao.queryByApplicantId(applicantId);
leavePOList.forEach(leavePO -> {
List<ApprovalInfoPO> approvalInfoPOList = approvalInfoDao.queryByLeaveId(leavePO.getId());
leavePO.setHistoryApprovalInfoPOList(approvalInfoPOList);
});
return leavePOList;
}
@Override
public List<LeavePO> queryByApproverId(String approverId) {
List<LeavePO> leavePOList = leaveDao.queryByApproverId(approverId);
leavePOList.forEach(leavePO -> {
List<ApprovalInfoPO> approvalInfoPOList = approvalInfoDao.queryByLeaveId(leavePO.getId());
leavePO.setHistoryApprovalInfoPOList(approvalInfoPOList);
});
return leavePOList;
}
}
这里为什么没有使用一对多、多对对呢?时间紧任务重或者并发量不高时可以使用,后期并发量起来了后,数据库将成为瓶颈。
JPA/Hibernate注解:@.NEToMany、@ManyToOne、@ManyToMany;
MyBatis注解:
@Results(id="", value={@Result(column="", property="", jdbcType=JdbcType.INTEGER),
@Result(column="", property="", JAVAType=xx.class,one=@One(select="com.xx..XxMapper.selectById"))
})
或
@Results(id="",value = { @Result(property = "", column = ""),
@Result(property = "xxList", javaType=List.class, many=@Many(select=""), column = "")});
Mybatis xml: association、collection。
工厂模式
工厂模式将与业务无关的职能从聚合根中剥离,放在工厂中统一创建和初始化。
//可考虑使用MapStruct
@Service
public class LeaveFactory {
public LeavePO createLeavePO(Leave leave) {
LeavePO leavePO = new LeavePO();
leavePO.setId(UUID.randomUUID().toString());
leavePO.setApplicantId(leave.getApplicant().getPersonId());
leavePO.setApplicantName(leave.getApplicant().getPersonName());
leavePO.setApproverId(leave.getApprover().getPersonId());
leavePO.setApproverName(leave.getApprover().getPersonName());
leavePO.setStartTime(leave.getStartTime());
leavePO.setStatus(leave.getStatus());
List<ApprovalInfoPO> historyApprovalInfoPOList = approvalInfoPOListFromDO(leave);
leavePO.setHistoryApprovalInfoPOList(historyApprovalInfoPOList);
return leavePO;
}
public Leave getLeave(LeavePO leavePO) {
Leave leave = new Leave();
Applicant applicant = Applicant.builder()
.personId(leavePO.getApplicantId())
.personName(leavePO.getApplicantName())
.build();
leave.setApplicant(applicant);
Approver approver = Approver.builder()
.personId(leavePO.getApproverId())
.personName(leavePO.getApproverName())
.build();
leave.setApprover(approver);
leave.setStartTime(leavePO.getStartTime());
leave.setStatus(leavePO.getStatus());
List<ApprovalInfo> approvalInfos = getApprovalInfos(leavePO.getHistoryApprovalInfoPOList());
leave.setHistoryApprovalInfos(approvalInfos);
return leave;
}
public LeaveEventPO createLeaveEventPO(LeaveEvent leaveEvent){
LeaveEventPO eventPO = new LeaveEventPO();
eventPO.setLeaveEventType(leaveEvent.getLeaveEventType());
eventPO.setSource(leaveEvent.getSource());
eventPO.setTimestamp(leaveEvent.getTimestamp());
eventPO.setData(JSON.toJSONString(leaveEvent.getData()));
return eventPO;
}
private List<ApprovalInfoPO> approvalInfoPOListFromDO(Leave leave) {
return leave.getHistoryApprovalInfos()
.stream()
.map(this::approvalInfoPOFromDO)
.collect(Collectors.toList());
}
private ApprovalInfoPO approvalInfoPOFromDO(ApprovalInfo approvalInfo){
ApprovalInfoPO po = new ApprovalInfoPO();
po.setApproverId(approvalInfo.getApprover().getPersonId());
po.setApproverLevel(approvalInfo.getApprover().getLevel());
po.setApproverName(approvalInfo.getApprover().getPersonName());
po.setApprovalInfoId(approvalInfo.getApprovalInfoId());
po.setMsg(approvalInfo.getMsg());
po.setTime(approvalInfo.getTime());
return po;
}
private ApprovalInfo approvalInfoFromPO(ApprovalInfoPO approvalInfoPO){
ApprovalInfo approvalInfo = new ApprovalInfo();
approvalInfo.setApprovalInfoId(approvalInfoPO.getApprovalInfoId());
Approver approver = Approver.builder()
.personId(approvalInfoPO.getApproverId())
.personName(approvalInfoPO.getApproverName())
.level(approvalInfoPO.getApproverLevel())
.build();
approvalInfo.setApprover(approver);
approvalInfo.setMsg(approvalInfoPO.getMsg());
approvalInfo.setTime(approvalInfoPO.getTime());
return approvalInfo;
}
private List<ApprovalInfo> getApprovalInfos(List<ApprovalInfoPO> approvalInfoPOList){
return approvalInfoPOList.stream()
.map(this::approvalInfoFromPO)
.collect(Collectors.toList());
}
}
服务的组合和编排
应用层的应用服务主要完成领域服务的组合与编排。
@Service
public class LeaveApplicationService {
@Autowired
LeaveDomainService leaveDomainService;
@Autowired
PersonDomainService personDomainService;
@Autowired
ApprovalRuleDomainService approvalRuleDomainService;
/**
* 创建一个请假申请并为审批人生成任务
* @param leave
*/
public void createLeaveInfo(Leave leave){
int leaderMaxLevel = approvalRuleDomainService.getLeaderMaxLevel(leave.getApplicant().getPersonType(), leave.getType().toString(), leave.getDuration());
Person approver = personDomainService.findFirstApprover(leave.getApplicant().getPersonId(), leaderMaxLevel);
leaveDomainService.createLeave(leave, leaderMaxLevel, Approver.fromPerson(approver));
}
/**
* 更新请假单基本信息
* @param leave
*/
public void updateLeaveInfo(Leave leave){
leaveDomainService.updateLeaveInfo(leave);
}
/**
* 提交审批,更新请假单信息
* @param leave
*/
public void submitApproval(Leave leave){
//find next approver
Person approver = personDomainService.findNextApprover(leave.getApprover().getPersonId(), leave.getLeaderMaxLevel());
leaveDomainService.submitApproval(leave, Approver.fromPerson(approver));
}
public Leave getLeaveInfo(String leaveId){
return leaveDomainService.getLeaveInfo(leaveId);
}
public List<Leave> queryLeaveInfosByApplicant(String applicantId){
return leaveDomainService.queryLeaveInfosByApplicant(applicantId);
}
public List<Leave> queryLeaveInfosByApprover(String approverId){
return leaveDomainService.queryLeaveInfosByApprover(approverId);
}
}
服务接口的提供
facade门面接口主要抽象出Controller Api作为OpenFeign调用的接口门面类。
/**
* @author lyonardo
* @Description
* @createTime 2020年03月08日 15:06:00
*/
@FeignClient(name = "leave-service", path = "/leave")
public interface LeaveFeignClient {
@PostMapping("/submit")
Response submitApproval(LeaveDTO leaveDTO);
@PostMapping("/{leaveId}")
Response findById(@PathVariable String leaveId);
/**
* 根据申请人查询所有请假单
* @param applicantId
* @return
*/
@PostMapping("/query/applicant/{applicantId}")
Response queryByApplicant(@PathVariable String applicantId);
/**
* 根据审批人id查询待审批请假单(待办任务)
* @param approverId
* @return
*/
@PostMapping("/query/approver/{approverId}")
Response queryByApprover(@PathVariable String approverId)();
}
实现类
@RestController
@RequestMapping("/leave")
@Slf4j
public class LeaveApi {
@Autowired
LeaveApplicationService leaveApplicationService;
@PostMapping("/create")
public Response createLeaveInfo(LeaveDTO leaveDTO){
Leave leave = LeaveAssembler.toDO(leaveDTO);
leaveApplicationService.createLeaveInfo(leave);
return Response.ok();
}
@PutMapping("/update")
public Response updateLeaveInfo(LeaveDTO leaveDTO){
Leave leave = LeaveAssembler.toDO(leaveDTO);
leaveApplicationService.updateLeaveInfo(leave);
return Response.ok();
}
@PostMapping("/submit")
public Response submitApproval(LeaveDTO leaveDTO){
Leave leave = LeaveAssembler.toDO(leaveDTO);
leaveApplicationService.submitApproval(leave);
return Response.ok();
}
@PostMapping("/{leaveId}")
public Response findById(@PathVariable String leaveId){
Leave leave = leaveApplicationService.getLeaveInfo(leaveId);
return Response.ok(LeaveAssembler.toDTO(leave));
}
/**
* 根据申请人查询所有请假单
* @param applicantId
* @return
*/
@PostMapping("/query/applicant/{applicantId}")
public Response queryByApplicant(@PathVariable String applicantId){
List<Leave> leaveList = leaveApplicationService.queryLeaveInfosByApplicant(applicantId);
List<LeaveDTO> leaveDTOList = leaveList.stream().map(leave -> LeaveAssembler.toDTO(leave)).collect(Collectors.toList());
return Response.ok(leaveDTOList);
}
/**
* 根据审批人id查询待审批请假单(待办任务)
* @param approverId
* @return
*/
@PostMapping("/query/approver/{approverId}")
public Response queryByApprover(@PathVariable String approverId){
List<Leave> leaveList = leaveApplicationService.queryLeaveInfosByApprover(approverId);
List<LeaveDTO> leaveDTOList = leaveList.stream().map(leave -> LeaveAssembler.toDTO(leave)).collect(Collectors.toList());
return Response.ok(leaveDTOList);
}
}
数据组装层
LeaveAssembler
//可使用MapStruct做对象转换和组装
public class LeaveAssembler {
public static LeaveDTO toDTO(Leave leave){
LeaveDTO dto = new LeaveDTO();
dto.setLeaveId(leave.getId());
dto.setLeaveType(leave.getType().toString());
dto.setStatus(leave.getStatus().toString());
dto.setStartTime(DateUtil.formatDateTime(leave.getStartTime()));
dto.setEndTime(DateUtil.formatDateTime(leave.getEndTime()));
dto.setCurrentApprovalInfoDTO(ApprovalInfoAssembler.toDTO(leave.getCurrentApprovalInfo()));
List<ApprovalInfoDTO> historyApprovalInfoDTOList = leave.getHistoryApprovalInfos()
.stream()
.map(historyApprovalInfo -> ApprovalInfoAssembler.toDTO(leave.getCurrentApprovalInfo()))
.collect(Collectors.toList());
dto.setHistoryApprovalInfoDTOList(historyApprovalInfoDTOList);
dto.setDuration(leave.getDuration());
return dto;
}
public static Leave toDO(LeaveDTO dto){
Leave leave = new Leave();
leave.setId(dto.getLeaveId());
leave.setApplicant(ApplicantAssembler.toDO(dto.getApplicantDTO()));
leave.setApprover(ApproverAssembler.toDO(dto.getApproverDTO()));
leave.setCurrentApprovalInfo(ApprovalInfoAssembler.toDO(dto.getCurrentApprovalInfoDTO()));
List<ApprovalInfo> historyApprovalInfoDTOList = dto.getHistoryApprovalInfoDTOList()
.stream()
.map(ApprovalInfoAssembler::toDO)
.collect(Collectors.toList());
leave.setHistoryApprovalInfos(historyApprovalInfoDTOList);
return leave;
}
}