B/S架构，三层架构，跟分层解耦

B/S架构：

浏览器 → Web 服务器 → 数据库（即浏览器通过web服务器与数据库交互）

• B 端：浏览器
• S 端：
  • Tomcat
  • Controller
  • Service
  • Dao/Mapper
  • 数据库

TomCate是标准的标准 Java Web 服务器。

用于

• 监听端口（8080）
• 接收 HTTP 请求
• 解析请求
• 把请求交给你的项目（Servlet / SpringMVC）
• 返回 HTTP 响应

浏览器（B） ↓ HTTP 请求（底层走 Socket 连接） ┌───────────────────────────┐ │ sereverSocket │ ← 网络通信通道（TCP 连接）,接受请求建立通道，创建socket读 └───────────────────────────┘ 取数据 ↓ ┌─────────────────────┐ │ Tomcat服务器 │ ←—— 服务器容器，不属于三层任何一层，监听socket,接受请求 └─────────────────────┘ ↓ 把请求交给 Controller ┌─────────────────────┐ │ Controller │ ←—— 表现层（三层之一） │ Service │ ←—— 业务层 │ Dao/Mapper │ ←—— 数据访问层 └─────────────────────┘ ↓ 数据库 返回是原路返回

三层架构

1. 表现层（Presentation Layer）——Controller
2. 业务逻辑层（Business Logic Layer）——Service
3. 数据访问层（Data Access Layer）——Dao / Mapper

另外还有配套的实体类层（Entity/Model/Pojo），不属于三层，但必须一起用。

表现层（Controller）

• 接收前端（浏览器 / Postman）发来的求
• 参数校验、简单格式处理
• 调用 Service 层完成业务
• 把结果封装成 JSON 返回给前端
• 不写业务逻辑，不直接操作数据库

业务逻辑层（Service）

• 真正写业务逻辑的地方
• 事务控制、权限判断、数据计算、流程编排
• 调用 Dao/Mapper 层操作数据库
• 一个 Service 可以调用多个 Dao，也可以调用其他 Service

数据访问层（Dao / Mapper）

• 只负责和数据库交互
• 增删改查（CRUD）
• 写 SQL 或使用 MyBatis/MyBatis-Plus/JPA
• 不处理业务逻辑，只做数据存取

调用关系

只能从上往下调用，不能反向！

前端 →Controller → Service → Dao/Mapper→ 数据库

标准的包结构

com.xxx ├── controller │ └── UserController.java // 控制器 ├── service │ ├── UserService.java // 接口！ │ └── impl │ └── UserServiceImpl.java // 实现类 ├── mapper │ └── UserMapper.java └── entity └── User.java

分层的作用利于团队协作，方便更改，解耦....

分层解耦

分层

把代码按职责切成三层：

• Controller（表现层）：接收请求、返回结果
• Service（业务层）：写逻辑、判断、计算
• Dao/Mapper（数据层）：操作数据库

各干各的

耦合

就是就是类和类绑得太紧。

public class UserController { private UserService userService = new UserServiceImpl(); }

Controller直接 new Service→ Controller 死死依赖 UserServiceImpl→ 这就叫高耦合

耦合的坏处：

• 换实现类必须改源码
• 一处改，处处动
• 代码难维护、难测试

解耦

就是解除这种硬绑定，让类之间只依赖 “接口”，不依赖具体类。

解耦的操作依赖于IOC + DI + Bean 这套 Spring 机制

IOC + DI + Bean

1. IOC 控制反转 —— 解耦的思想

IOC 前：

• 对象是你自己 new，控制权在自己写的代码里

IOC 之后：

• 对象由Spring 容器创建，控制权从代码 → 反转给容器，变成被动接

2.Bean = Spring 容器创建并管理的对象（被IOC 注解标记类后就会被spring创建）

• Controller、Service、Dao 这些类的实例，是 由Spring 创建的，放在 Spring 容器里统一管理

3. DI 依赖注入 —— IOC 的具体动作。

DI 做的事：

• Spring 容器里已经有一堆 Bean 了，只用在类里写@Autowired，Spring 自动把对应的 Bean 赋值给你的变量，全程不用 new，不用管对象从哪来

这就叫依赖注入。

完整的讲就是

先用 IOC 相关注解（@RestController、@Service、@Repository、@Component）标记类 → 告诉 Spring：这个类要创建对象，放进容器里。 Spring 项目启动时，自动扫描这些类，自己 new 出对象，放进 Spring 容器。 容器里的这些对象，就叫 Bean。 然后用 DI 注解（@Autowired）告诉 Spring：把容器里对应的 Bean 拿过来，赋值给我这个变量。

IOC相关注解

现在

//Controller @RestController // 标记：交给容器管理 @RequestMapping("/user") public class UserController { // 连接方式：注入 Service @Autowired private UserService userService;//接口变量，用来装它实现类对象的变量 @GetMapping("/user/{id}") public User get(@PathVariable Long id) { // 调用接口方法 return userService.findById(id); } // Service 接口 public interface UserService { User getById(Long id); } // Service 实现 @Service public class UserServiceImpl implements UserService { // 注入 Mapper @Autowired private UserMapper userMapper; @Override public User findById(Long id) { // 1. 查数据库 User user = userMapper.selectById(id); // 2. 业务判断 if (user == null) { throw new RuntimeException("用户不存在"); } // 3. 返回给 Controller return user; } } @Mapper//Mapper(接口)代替了 @Repository 因为MyBatis会自动生成实现类(代理对象)，并交给Spring 生成Bean public interface UserMapper { // 写 SQL，操作数据库 // MyBatis 帮你写的 实现类 // (你看不见，但是真的存在) public class **UserMapperImpl** implements UserMapper { // 真正干活的代码 (JDBC连接数据库) } }

以前

public class UserController { // 1. 声明一个变量 private UserService userService; public UserController() { // 2. 自己 new 对象，赋值给变量 userService = new UserServiceImpl(); } }