DDD框架落地實戰

./ddd-application  // 應用層
├── pom.xml
└── src
    └── main
        └── java
            └── com
                └── ddd
                    └── applicaiton
                        ├── converter
                        │   └── UserApplicationConverter.java // 類型轉換器
                        └── impl
                            └── AuthrizeApplicationServiceImpl.java // 業務邏輯
./ddd-common
├── ddd-common // 通用類庫
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── com
│                   └── ddd
│                       └── common
│                           ├── exception // 異常
│                           │   ├── ServiceException.java
│                           │   └── ValidationException.java
│                           ├── result // 返回結果集
│                           │   ├── BaseResult.javar
│                           │   ├── Page.java
│                           │   ├── PageResult.java
│                           │   └── Result.java
│                           └── util // 通用工具
│                               ├── GsonUtil.java
│                               └── ValidationUtil.java
├── ddd-common-application // 業務層通用模塊
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── com
│                   └── ddd
│                       └── applicaiton
│                           ├── dto // DTO
│                           │   ├── RoleInfoDTO.java
│                           │   └── UserRoleDTO.java
│                           └── servic // 業務接口
│                               └── AuthrizeApplicationService.java
├── ddd-common-domain
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── com
│                   └── ddd
│                       └── domain
│                           ├── event // 領域事件
│                           │   ├── BaseDomainEvent.java
│                           │   └── DomainEventPublisher.java
│                           └── service // 領域接口
│                               └── AuthorizeDomainService.java
└── ddd-common-infra
    ├── pom.xml
    └── src
        └── main
            └── java
                └── com
                    └── ddd
                        └── infra
                            ├── domain // DO
                            │   └── AuthorizeDO.java
                            ├── dto 
                            │   ├── AddressDTO.java
                            │   ├── RoleDTO.java
                            │   ├── UnitDTO.java
                            │   └── UserRoleDTO.java
                            └── repository
                                ├── UserRepository.java // 領域倉庫
                                └── mybatis
                                    └── entity // PO
                                        ├── BaseUuidEntity.java
                                        ├── RolePO.java
                                        ├── UserPO.java
                                        └── UserRolePO.java
./ddd-domian  // 領域層
├── pom.xml
└── src
    └── main
        └── java
            └── com
                └── ddd
                    └── domain
                        ├── event // 領域事件
                        │   ├── DomainEventPublisherImpl.java
                        │   ├── UserCreateEvent.java
                        │   ├── UserDeleteEvent.java
                        │   └── UserUpdateEvent.java
                        └── impl // 領域邏輯
                            └── AuthorizeDomainServiceImpl.java
./ddd-infra  // 基礎服務層
├── pom.xml
└── src
    └── main
        └── java
            └── com
                └── ddd
                    └── infra
                        ├── config
                        │   └── InfraCoreConfig.java  // 掃描Mapper文件
                        └── repository
                            ├── converter
                            │   └── UserConverter.java // 類型轉換器
                            ├── impl
                            │   └── UserRepositoryImpl.java
                            └── mapper
                                ├── RoleMapper.java
                                ├── UserMapper.java
                                └── UserRoleMapper.java
./ddd-interface
├── ddd-api  // 用戶接口層
│   ├── pom.xml
│   └── src
│       └── main
│           ├── java
│           │   └── com
│           │       └── ddd
│           │           └── api
│           │               ├── DDDFrameworkApiApplication.java // 啟動入口
│           │               ├── converter
│           │               │   └── AuthorizeConverter.java // 類型轉換器
│           │               ├── model
│           │               │   ├── req // 入參 req
│           │               │   │   ├── AuthorizeCreateReq.java
│           │               │   │   └── AuthorizeUpdateReq.java
│           │               │   └── vo  // 輸出 VO
│           │               │       └── UserAuthorizeVO.java
│           │               └── web     // API
│           │                   └── AuthorizeController.java
│           └── resources // 系統配置
│               ├── application.yml
│           └── resources // Sql文件
│               └── init.sql
└── ddd-task
    └── pom.xml
./pom.xml

create table t_user
(
    id           bigint auto_increment comment '主鍵' primary key,
    user_name    varchar(64)                        null comment '用戶名',
    password     varchar(255)                       null comment '密碼',
    real_name    varchar(64)                        null comment '真實姓名',
    phone        bigint                             null comment '手機號',
    province     varchar(64)                        null comment '用戶名',
    city         varchar(64)                        null comment '用戶名',
    county       varchar(64)                        null comment '用戶名',
    unit_id      bigint                             null comment '單位id',
    unit_name    varchar(64)                        null comment '單位名稱',
    gmt_create   datetime default CURRENT_TIMESTAMP not null comment '創建時間',
    gmt_modified datetime default CURRENT_TIMESTAMP not null on update CURRENT_TIMESTAMP comment '修改時間',
    deleted      bigint   default 0                 not null comment '是否刪除，非0為已刪除'
)comment '用戶表' collate = utf8_bin;
create table t_role
(
    id           bigint auto_increment comment '主鍵' primary key,
    name         varchar(256)                       not null comment '名稱',
    code         varchar(64)                        null comment '角色code',
    gmt_create   datetime default CURRENT_TIMESTAMP not null comment '創建時間',
    gmt_modified datetime default CURRENT_TIMESTAMP not null on update CURRENT_TIMESTAMP comment '修改時間',
    deleted      bigint   default 0                 not null comment '是否已刪除'
)comment '角色表' charset = utf8;
create table t_user_role (
    id           bigint auto_increment comment '主鍵id' primary key,
    user_id      bigint                             not null comment '用戶id',
    role_id      bigint                             not null comment '角色id',
    gmt_create   datetime default CURRENT_TIMESTAMP not null comment '創建時間',
    gmt_modified datetime default CURRENT_TIMESTAMP not null comment '修改時間',
    deleted      bigint   default 0                 not null comment '是否已刪除'
)comment '用戶角色關聯表' charset = utf8;

public AuthorizeDO save(AuthorizeDO user) {
    UserPO userPo = userConverter.toUserPo(user);
    if(Objects.isNull(user.getUserId())){
        userMapper.insert(userPo);
        user.setUserId(userPo.getId());
    } else {
        userMapper.updateById(userPo);
        userRoleMapper.delete(Wrappers.<UserRolePO>lambdaQuery()
                .eq(UserRolePO::getUserId, user.getUserId()));
    }
    List<UserRolePO> userRolePos = userConverter.toUserRolePo(user);
    userRolePos.forEach(userRoleMapper::insert);
    return this.query(user.getUserId());
}

// 用戶領域倉儲
public interface UserRepository {
    // 刪除
    void delete(Long userId);
    // 查詢
    AuthorizeDO query(Long userId);
    // 保存
    AuthorizeDO save(AuthorizeDO user);
}

public class AuthorizeDO {
    // 用戶ID
    private Long userId;
    // 用戶名
    private String userName;
    // 真實姓名
    private String realName;
    // 手機號
    private String phone;
    // 密碼
    private String password;
    // 用戶單位
    private UnitDTO unit;
    // 用戶地址
    private AddressDTO address;
    // 用戶角色
    private List<RoleDTO> roles;
}

@Service
public class AuthorizeDomainServiceImpl implements AuthorizeDomainService {
    @Override
    // 設置單位信息
    public void associatedUnit(AuthorizeDO authorizeDO) {
        String unitName = "武漢小米";// TODO: 通過第三方獲取
        authorizeDO.getUnit().setUnitName(unitName);
    }
}

/**
 * 領域事件基類
 *
 * @author louzai
 * @since 2021/11/22
 */
@Getter
@Setter
@NoArgsConstructor
public abstract class BaseDomainEvent<T> implements Serializable {
    private static final long serialVersionUID = 1465328245048581896L;
    /**
     * 發生時間
     */
    private LocalDateTime occurredOn;
    /**
     * 領域事件數據
     */
    private T data;
    public BaseDomainEvent(T data) {
        this.data = data;
        this.occurredOn = LocalDateTime.now();
    }
}
/**
 * 用戶新增領域事件
 *
 * @author louzai
 * @since 2021/11/20
 */
public class UserCreateEvent extends BaseDomainEvent<AuthorizeDO> {
    public UserCreateEvent(AuthorizeDO user) {
        super(user);
    }
}

/**
 * 領域事件發佈實現類
 *
 * @author louzai
 * @since 2021/11/20
 */
@Component
@Slf4j
public class DomainEventPublisherImpl implements DomainEventPublisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;
    @Override
    public void publishEvent(BaseDomainEvent event) {
        log.debug("發佈事件,event:{}", GsonUtil.gsonToString(event));
        applicationEventPublisher.publishEvent(event);
    }
}

@Transactional(rollbackFor = Exception.class)
public void createUserAuthorize(UserRoleDTO userRoleDTO){
    // DTO轉為DO
    AuthorizeDO authorizeDO = userApplicationConverter.toAuthorizeDo(userRoleDTO);
    // 關聯單位單位信息
    authorizeDomainService.associatedUnit(authorizeDO);
    // 存儲用戶
    AuthorizeDO saveAuthorizeDO = userRepository.save(authorizeDO);
    // 發佈用戶新建的領域事件
    domainEventPublisher.publishEvent(new UserCreateEvent(saveAuthorizeDO));
}

@Override
  public UserRoleDTO queryUserAuthorize(Long userId) {
      // 查詢用戶授權領域數據
      AuthorizeDO authorizeDO = userRepository.query(userId);
      if (Objects.isNull(authorizeDO)) {
          throw ValidationException.of("UserId is not exist.", null);
      }
      // DO轉DTO
      return userApplicationConverter.toAuthorizeDTO(authorizeDO);
  }

@GetMapping("/query")
public Result<UserAuthorizeVO> query(@RequestParam("userId") Long userId){
    UserRoleDTO userRoleDTO = authrizeApplicationService.queryUserAuthorize(userId);
    Result<UserAuthorizeVO> result = new Result<>();
    result.setData(authorizeConverter.toVO(userRoleDTO));
    result.setCode(BaseResult.CODE_SUCCESS);
    return result;
}
@PostMapping("/save")
public Result<Object> create(@RequestBody AuthorizeCreateReq authorizeCreateReq){
    authrizeApplicationService.createUserAuthorize(authorizeConverter.toDTO(authorizeCreateReq));
    return Result.ok(BaseResult.INSERT_SUCCESS);
}

git clone [email protected]:lml200701158/ddd-framework.git