美文网首页
五个分层维度：SpringBoot工程分层实战

五个分层维度：SpringBoot工程分层实战

作者: 在中国喝Java | 来源:发表于2022-12-11 10:31 被阅读0次

1 分层思想
计算机领域有一句话：计算机中任何问题都可通过增加一个虚拟层解决。这句体现了分层思想重要性，分层思想同样适用于Java工程架构。
分层优点是每层只专注本层工作，可以类比设计模式单一职责原则，或者经济学比较优势原理，每层只做本层最擅长的事情。
分层缺点是层之间通信时，需要通过适配器，翻译成本层或者下层可以理解的信息，通信成本有所增加。
我认为工程分层需要从五个维度思考：
(1) 单一
每层只处理一类事情，满足单一职责原则
(2) 降噪
信息在每一层进行传输，满足最小知识原则，只向下层传输必要信息
(3) 适配
每层都需要一个适配器，翻译信息为本层或者下层可以理解的信息
(4) 业务
业务对象可以整合业务逻辑，例如使用充血模型整合业务
(5) 数据
数据对象尽量纯净，尽量不要聚合业务

1.2 九层结构
综上所述SpringBoot工程可以分为九层：

工具层：util
整合层：integration
基础层：infrastructure
服务层：service
领域层：domain
门面层：facade
控制层：controller
客户端：client
启动层：boot

2 分层详解
创建测试项目user-demo-service：
user-demo-service
-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-service
-user-demo-service-util
复制代码

2.1 util
工具层承载工具代码
不依赖本项目其它模块
只依赖一些通用工具包
user-demo-service-util
-/src/main/java
-date
-DateUtil.java
-json
-JSONUtil.java
-validate
-BizValidator.java
复制代码

2.2 infrastructure
基础层核心是承载数据访问，entity实体对象承载在本层。

2.2.1 项目结构
代码层分为两个领域：

player：运动员
game：比赛

每个领域具有两个子包：

entity
mapper

user-demo-service-infrastructure
-/src/main/java
-player
-entity
-PlayerEntity.java
-mapper
-PlayerEntityMapper.java
-game
-entity
-GameEntity.java
-mapper
-GameEntityMapper.java
-/src/main/resources
-mybatis
-sqlmappers
-gameEntityMappler.xml
-playerEntityMapper.xml
复制代码

2.2.2 本项目间依赖关系
infrastructure只依赖工具模块
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-util</artifactId>
</dependency>
复制代码

2.2.3 核心代码
创建运动员数据表：
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保存在数据库，这体现了数据层尽量纯净，不要整合过多业务，解析任务应该放在业务层：
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对象：
@Repository
public interface PlayerEntityMapper {
int insert(PlayerEntity record);
int updateById(PlayerEntity record);
PlayerEntity selectById(@Param("playerId") String playerId);
}
复制代码

2.3 domain
2.3.1 概念说明
领域层是DDD流行兴起之概念
可以通过三组对比理解领域层

领域对象 VS 数据对象
领域对象 VS 业务对象
领域层 VS 业务层

(1) 领域对象 VS 数据对象
数据对象字段尽量纯净，使用基本类型
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;
}
复制代码

以查询结果领域对象为例
领域对象需要体现业务含义
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 业务对象
业务对象同样会体现业务，领域对象和业务对象有什么不同呢？其中一个最大不同是领域对象采用充血模型聚合业务。
运动员新增业务对象：
public class PlayerCreateBO {
private String playerName;
private Integer height;
private Integer weight;
private GamePerformanceVO gamePerformance;
private MaintainCreateVO maintainInfo;
}
复制代码

运动员新增领域对象：
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.3.2 项目结构
代码层分为两个领域：

player：运动员
game：比赛

每个领域具有三个子包：

domain：领域对象
event：领域事件
vo：值对象

user-demo-service-domain
-/src/main/java
-base
-domain
-BaseDomain.java
-event
-BaseEvent.java
-vo
-BaseVO.java
-MaintainCreateVO.java
-MaintainUpdateVO.java
-player
-domain
-PlayerCreateDomain.java
-PlayerUpdateDomain.java
-PlayerQueryResultDomain.java
-event
-PlayerUpdateEvent.java
-vo
-GamePerformanceVO.java
-game
-domain
-GameCreateDomain.java
-GameUpdateDomain.java
-GameQueryResultDomain.java
-event
-GameUpdateEvent.java
-vo
-GameSubstitutionVO.java
复制代码

2.3.3 本项目间依赖关系
domain依赖本项目两个模块：

util
client

之所以依赖client模块是因为领域对象聚合了业务校验，以下信息需要暴露至外部：

BizException
ErrorCodeBizEnum

<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-util</artifactId>
</dependency>
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-client</artifactId>
</dependency>
复制代码

2.3.4 核心代码
以运动员修改领域对象为例：
// 运动员修改领域对象
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);
    }
}

}
复制代码

2.4 service
2.4.1 项目结构
user-demo-service-service
-/src/main/java
-player
-adapter
-PlayerServiceAdapter.java
-event
-PlayerMessageSender.java
-service
-PlayerService.java
-game
-adapter
-GameServiceAdapter.java
-event
-GameMessageSender.java
-service
-GameService.java
复制代码

2.4.2 本项目间依赖关系
service依赖本项目四个模块：

util
domain
integration
infrastructure

<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-domain</artifactId>
</dependency>
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-infrastructure</artifactId>
</dependency>
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-util</artifactId>
</dependency>
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-integration</artifactId>
</dependency>
复制代码

2.4.3 核心代码
以运动员编辑服务为例：
// 运动员服务
public class PlayerService {

@Resource
private PlayerEntityMapper playerEntityMapper;
@Resource
private PlayerMessageSender playerMessageSender;
@Resource
private PlayerServiceAdapter playerServiceAdapter;

public boolean updatePlayer(PlayerUpdateDomain player) {
    AssertUtil.notNull(player, new BizException(ErrorCodeBizEnum.ILLEGAL_ARGUMENT));
    player.validate();
    PlayerEntity entity = playerServiceAdapter.convertUpdate(player);
    playerEntityMapper.updateById(entity);
    playerMessageSender.sendPlayerUpdatemessage(player);
    return true;
}

}

// 运动员消息服务
public class PlayerMessageSender {

@Resource
private PlayerServiceAdapter playerServiceAdapter;

public boolean sendPlayerUpdatemessage(PlayerUpdateDomain domain) {
    PlayerUpdateEvent event = playerServiceAdapter.convertUpdateEvent(domain);
    log.info("sendPlayerUpdatemessage event={}", event);
    return true;
}

}

// 服务适配器
public class PlayerServiceAdapter {

// domain -> entity
public PlayerEntity convertUpdate(PlayerUpdateDomain domain) {
    PlayerEntity player = new PlayerEntity();
    player.setPlayerId(domain.getPlayerId());
    player.setPlayerName(domain.getPlayerName());
    player.setWeight(domain.getWeight());
    player.setHeight(domain.getHeight());
    if (null != domain.getGamePerformance()) {
        player.setGamePerformance(JacksonUtil.bean2Json(domain.getGamePerformance()));
    }
    String updator = domain.getMaintainInfo().getUpdator();
    Date updateTime = domain.getMaintainInfo().getUpdateTime();
    player.setUpdator(updator);
    player.setUpdateTime(updateTime);
    return player;
}

// domain -> event
public PlayerUpdateEvent convertUpdateEvent(PlayerUpdateDomain domain) {
    PlayerUpdateEvent event = new PlayerUpdateEvent();
    event.setPlayerUpdateDomain(domain);
    event.setMessageId(UUID.randomUUID().toString());
    event.setMessageId(PlayerMessageType.UPDATE.getMsg());
    return event;
}

}
复制代码

2.5 intergration
本项目可能会依赖外部服务，那么将外部DTO转换为本项目可以理解的对象，需要在本层处理。

2.5.1 项目结构
假设本项目调用了用户中心服务：
user-demo-service-intergration
-/src/main/java
-user
-adapter
-UserClientAdapter.java
-proxy
-UserClientProxy.java
复制代码

2.5.2 本项目间依赖关系
intergration依赖本项目两个模块：

util
domain

之所以依赖domain模块，是因为本层需要将外部DTO转换为本项目可以理解的对象，这些对象就放在domain模块。
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-domain</artifactId>
</dependency>
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-util</artifactId>
</dependency>
复制代码

2.5.3 核心代码
现在我们将外部对象UserClientDTO
转换为本项目领域对象UserInfoDomain

(1) 外部服务
// 外部对象
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) 本项目领域对象
domain模块新增user领域：
user-demo-service-domain
-/src/main/java
-user
-domain
-UserDomain.java
-vo
-UserAddressVO.java
-UserContactVO.java
复制代码

user领域对象代码：
// 用户领域
public class UserInfoDomain extends BaseDomain {
private UserContactVO contactInfo;
private UserAddressVO addressInfo;
}

// 地址值对象
public class UserAddressVO extends BaseVO {
private String cityCode;
private String addressDetail;
}

// 联系方式值对象
public class UserContactVO extends BaseVO {
private String mobile;
}
复制代码

(3) 适配器
public class UserClientAdapter {

// third dto -> domain
public UserInfoDomain convertUserDomain(UserInfoClientDTO userInfo) {
    UserInfoDomain userDomain = new UserInfoDomain();
    UserContactVO contactVO = new UserContactVO();
    contactVO.setMobile(userInfo.getMobile());
    userDomain.setContactInfo(contactVO);

    UserAddressVO addressVO = new UserAddressVO();
    addressVO.setCityCode(userInfo.getCityCode());
    addressVO.setAddressDetail(userInfo.getAddressDetail());
    userDomain.setAddressInfo(addressVO);
    return userDomain;
}

}
复制代码

(4) 调用外部服务
public class UserClientProxy {

@Resource
private UserClientService userClientService;
@Resource
private UserClientAdapter userClientAdapter;

public UserInfoDomain getUserInfo(String userId) {
    UserInfoClientDTO user = userClientService.getUserInfo(userId);
    UserInfoDomain result = userClientAdapter.convertUserDomain(user);
    return result;
}

}
复制代码

2.6 facade + client
设计模式中有一种Facade模式，称为门面模式或者外观模式。这种模式提供一个简洁对外语义，屏蔽内部系统复杂性。
client承载数据对外传输对象DTO，facade承载对外服务，这两层必须满足最小知识原则，无关信息不必对外透出。
这样做有两个优点：

简洁性：对外服务语义明确简洁
安全性：敏感字段不能对外透出

2.6.1 项目结构
(1) client
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
-event
-PlayerUpdateEventDTO.java
-service
-PlayerClientService.java
复制代码

(2) facade
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
service

<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-domain</artifactId>
</dependency>
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-client</artifactId>
</dependency>
<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-service</artifactId>
</dependency>
复制代码

2.6.3 核心代码
(1) DTO
以查询运动员信息为例，查询结果DTO只封装最关键字段，例如运动员ID、创建时间、修改时间等业务不强字段就无须透出：
public class PlayerQueryResultDTO implements Serializable {
private String playerName;
private Integer height;
private Integer weight;
private GamePerformanceDTO gamePerformanceDTO;
}
复制代码

(2) 客户端服务
public interface PlayerClientService {
public ResultDTO<PlayerQueryResultDTO> queryById(String playerId);
}
复制代码

(3) 适配器
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) 服务实现
public class PlayerClientServiceImpl implements PlayerClientService {

@Resource
private PlayerService playerService;
@Resource
private PlayerFacadeAdapter playerFacadeAdapter;

@Override
public ResultDTO<PlayerQueryResultDTO> queryById(String playerId) {
    PlayerQueryResultDomain resultDomain = playerService.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 项目结构
user-demo-service-controller
-/src/main/java
-config
-CharsetConfig.java
-controller
-player
-PlayerController.java
-game
-GameController.java
复制代码

2.7.2 本项目依赖关系
controller依赖本项目一个模块：

facade

根据依赖传递原理同时依赖以下模块：

domain
client
service

<dependency>
<groupId>com.test.javafront</groupId>
<artifactId>user-demo-service-facade</artifactId>
</dependency>
复制代码

2.7.3 核心代码
@RestController
@RequestMapping("/player")
public class PlayerController {

@Resource
private PlayerClientService playerClientService;

@PostMapping("/add")
public ResultDTO<Boolean> add(@RequestHeader("test-login-info") String loginUserId, @RequestBody PlayerCreateDTO dto) {
    dto.setCreator(loginUserId);
    ResultCommonDTO<Boolean> resultDTO = playerClientService.addPlayer(dto);
    return resultDTO;
}

@PostMapping("/update")
public ResultDTO<Boolean> update(@RequestHeader("test-login-info") String loginUserId, @RequestBody PlayerUpdateDTO dto) {
    dto.setUpdator(loginUserId);
    ResultCommonDTO<Boolean> resultDTO = playerClientService.updatePlayer(dto);
    return resultDTO;
}

@GetMapping("/{playerId}/query")
public ResultDTO<PlayerQueryResultDTO> queryById(@RequestHeader("test-login-info") String loginUserId, @PathVariable("playerId") String playerId) {
    ResultCommonDTO<PlayerQueryResultDTO> resultDTO = playerClientService.queryById(playerId);
    return resultDTO;
}

}
复制代码

2.8 boot
boot作为启动层，只有启动入口代码

2.8.1 项目结构
所有模块代码均必须属于com.user.demo.service子路径
user-demo-service-boot
-/src/main/java
-com.user.demo.service
-MainApplication.java
复制代码

2.8.2 本项目间依赖
boot引用本项目所有模块

util
integration
infrastructure
service
domain
facade
controller
client

2.8.3 核心代码
@MapperScan("com.user.demo.service.infrastructure.*.mapper")
@SpringBootApplication
public class MainApplication {
public static void main(final String[] args) {
SpringApplication.run(MainApplication.class, args);
}
}
复制代码

3 文章总结
我们再次回顾分层五个思考维度：
(1) 单一
每层只处理一类事情，例如util只承载工具对象，integration只处理外部服务，每层职责单一且清晰
(2) 降噪
如无必要无增实体，例如查询结果DTO只透出最关键字段，例如运动员ID、创建时间、修改时间等业务不强字段无须透出
(3) 适配
service、facade、intergration层都存在适配器，翻译信息为本层或者下层可以理解的信息
(4) 业务
业务对象可以通过充血模型聚合业务，例如在业务对象中聚合业务校验逻辑
(5) 数据
数据对象要纯净，例如通过string类型保存比赛表现，数据层无需解析

相关文章

  • 研发二部JAVA后台开发规约（参考阿里JAVA代码规范）

    主要内容 工程规约 编码规约 异常处理日志规约 MySQL规约 安全规约 工程规约 应用分层： 工程分层如上图所示...

  • 为什么网络需要分层

    OSI与TCP/IP分层模型 为什么网络需要分层？ 大部分软件系统都是分层架构的，为了工程上实现/调试/维护方便。...

  • SpringBoot构建大数据开发框架

    为什么使用SpringBoot1、web工程分层设计，表现层、业务逻辑层、持久层，按照技术职能分为这几个内聚的部分...

  • SpringBoot(10) — 项目分层(下)

    前言 在上篇文章我们已经粗略的讲到了项目分层的知识。有感兴趣的可参考SpringBoot(9) — 项目分层(上)...

  • Pandas的分层索引MultiIndex使用

    为什么要学习分层索引MultiIndex？ 分层索引：在一个轴向上拥有多个索引层级，可以表达更高维度数据的形式； ...

  • 六边形架构设计

    分层架构是运用最为广泛的架构模式，把一个软件系统进行分层，是我们目前做工程项目的一个共识，我们最初学习的分层架构就...

  • 数据仓库设计

    数据仓库--事实表 数据仓库--事实表和维度表 DW数据仓库分层模型设计 如何优雅地设计数据分层 ODS DW D...

  • 【读书清单】好好思考09

    001降维攻击 降维攻击的关键，我们要对思考问题的逻辑进行分层，用更底层却更高维的维度分析。 002 分层逻辑 人...

  • SpringBoot(11) — JDBCTemplate的使用

    前言 在上节我们已经讲过了对于一个SpringBoot项目的分层知识，大家有兴趣的话，可参考SpringBoot(...

  • 浅析在校教育班课的出路

    一、教育分层，做公立校不敢做之事；更精确的分层，更低廉的分层成本（教务方向）1、现在培训机构的分层是被动分层，培训...

网友评论

      本文标题：五个分层维度：SpringBoot工程分层实战

      本文链接：https://www.haomeiwen.com/subject/elrfqdtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|五个分层维度：SpringBoot工程分层实战|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！