SpringBootWeb三层架构分层解耦

SpringBootWeb

1. SpringBootWeb案例
- 1.1 控制层未拆分代码
- 1.2 实体类
- 1.3 静态资源文件
- 1.4 txt文件
- 1.5 运行界面展示
2. 三层架构拆分
- 2.1 控制层（Controller）
- - 2.1.1 功能
  - 2.1.2 用户信息控制层
- 2.2 业务逻辑层（Service）
- - 2.2.2 功能
  - 2.2.3 业务逻辑层接口
  - 2.2.4 业务逻辑接口实现类
- 2.3 数据访问层（DAO）
- - 2.3.1 功能
  - 2.3.2 数据层接口
  - 2.3.3 数据层接口实现类
- 2.4 整体流程
- 2.5 三层架构拆分的优势
- 2.6 部分代码解释
- - 2.6.1 List & ArrayList
  - 2.6.2 面向对象的特性---多态
3. 分层解耦
- 3.1 核心概念
- - 3.1.1 耦合
  - 3.1.2 内聚
  - 3.1.3 控制反转 (IoC)
  - 3.1.4 依赖注入 (DI)
  - 3.1.5 Bean对象
- 3.2 相关注解
- - 3.2.1 @Component 注解
  - - 3.2.1.1 @Component 衍生注解
    - 3.2.1.2 @RestController 注解
  - 3.2.2 @ComponentScan注解
  - 3.2.3 @Autowired 注解
  - - 3.2.3.1 三种依赖注入方式
    - - 3.2.3.1.1 属性注入
      - 3.2.3.1.2 构造函数注入
      - 3.2.3.1.3 setter注入
    - 3.2.3.2 相同类型的bean三种解决方案
    - - 3.2.3.2.1 @Primary
      - 3.2.3.2.2 @Qualifier
      - 3.2.3.2.3 @Resource
- 3.3 三层架构解耦
- - 3.3.1 控制层解耦
  - 3.3.2 业务逻辑层解耦
  - 3.3.3 数据访问层解耦

本帖参考B站黑马程序员：全网首发AI+JavaWeb开发入门

1. SpringBootWeb案例

1.1 控制层未拆分代码

/**
 * 用户信息Controller
 */
@RestController //@Controller + @ResponseBody -----> 如果返回的是一个对象/集合 --> 转json --> 响应
public class UserController {
    @RequestMapping("/list")
    public List<User> list(){
        //1. 读取user.txt中的数据
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
        ArrayList<String> lines = IoUtil.readUtf8Lines(in, new ArrayList<>());

        //2. 业务逻辑处理: 解析数据, 封装User对象 --> List<User>
        List<User> userList = lines.stream().map(line -> {
            String[] split = line.split(",");
            return new User(
                    Integer.parseInt(split[0]),
                    split[1],
                    split[2],
                    split[3],
                    Integer.parseInt(split[4]),
                    LocalDateTime.parse(split[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        }).toList();

        //3. 响应数据
        return userList;
    }
}

1.2 实体类

com/itheima/pojo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private String name;
    private Integer age;
    private LocalDateTime updateTime;
}

1.3 静态资源文件

resources/static/user.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>用户列表数据</title>
    <style>
        /*定义css，美化表格*/
        table{
            border-collapse: collapse;
            width: 100%;
            margin-top: 20px;
            border: 1px solid #ccc;
            text-align: center;
            font-size: 14px;
        }
        tr {
            height: 40px;
        }
        th,td{
            border: 1px solid #ccc;
        }
        thead{
            background-color: #e8e8e8;
        }
        h1{
            text-align: center;
            font-family: 楷体;
        }
    </style>
</head>
<body>
    <div id="app">
        <h1>用户列表数据</h1>
        <!--定义一个表格,包括6列,分别是: ID, 用户名, 密码, 姓名, 年龄, 更新时间-->
        <table>
            <thead>
                <tr>
                    <th>ID</th>
                    <th>用户名</th>
                    <th>密码</th>
                    <th>姓名</th>
                    <th>年龄</th>
                    <th>更新时间</th>
                </tr>
            </thead>
            <tbody>
                <tr v-for="user in userList">
                    <td>{{user.id}}</td>
                    <td>{{user.username}}</td>
                    <td>{{user.password}}</td>
                    <td>{{user.name}}</td>
                    <td>{{user.age}}</td>
                    <td>{{user.updateTime}}</td>
                </tr>
            </tbody>
        </table>
    </div>

    <!--引入axios-->
    <script src="js/axios.min.js"></script>
    <script type="module">
        import { createApp } from './js/vue.esm-browser.js'
        createApp({
            data() {
                return {
                    userList: []
                }
            },
            methods: {
                async search(){
                    const result = await axios.get('/list');
                    this.userList = result.data;
                }
            },
            mounted() {
                this.search();
            }
        }).mount('#app')
    </script>
</body>
</html>

1.4 txt文件

resources/user.txt

1,daqiao,1234567890,大乔,22,2024-07-15 15:05:45
2,xiaoqiao,1234567890,小乔,18,2024-07-15 15:12:09
3,diaochan,1234567890,貂蝉,21,2024-07-15 15:07:16
4,lvbu,1234567890,吕布,28,2024-07-16 10:05:15
5,zhaoyun,1234567890,赵云,27,2024-07-16 11:03:28
6,zhangfei,1234567890,张飞,31,2024-07-16 11:03:28
7,guanyu,1234567890,关羽,34,2024-07-16 12:05:12
8,liubei,1234567890,刘备,37,2024-07-16 15:03:28

1.5 运行界面展示

在这里插入图片描述

2. 三层架构拆分

在这里插入图片描述
三层架构（Three-Tier Architecture）是软件开发中常用的一种设计模式，它将应用程序分为三个主要层次：表示层（Presentation Layer）、业务逻辑层（Business Logic Layer）和数据访问层（Data Access Layer）。这种架构有助于提高代码的可维护性、可扩展性和复用性。
在这里插入图片描述
三层架构（Three-Tier Architecture）是软件开发中常用的一种设计模式，它将应用程序分为三个主要层次：表示层（Presentation Layer）、业务逻辑层（Business Logic Layer）和数据访问层（Data Access Layer）。这种架构有助于提高代码的可维护性、可扩展性和复用性。以下是三层架构的详细解析：

2.1 控制层（Controller）

2.1.1 功能

接收请求：处理来自客户端（如浏览器或移动应用）的HTTP请求。
响应数据：根据业务逻辑处理结果生成相应的响应数据，并返回给客户端。

2.1.2 用户信息控制层

com/itheima/controller/UserController.java

/**
 * 用户信息Controller
 */
@RestController //@Controller + @ResponseBody -----> 如果返回的是一个对象/集合 --> 转json --> 响应
public class UserController {

    private UserService userService = new UserServiceImpl();

    @RequestMapping("/list")
    public List<User> list(){
        //1. 调用service
        List<User> userList = userService.list();
        //2. 响应数据
        return userList;
    }
}

2.2 业务逻辑层（Service）

2.2.2 功能

逻辑处理：实现业务逻辑，包括数据验证、业务规则处理等。
调用数据访问层：通过调用数据访问层的方法来操作数据库。

2.2.3 业务逻辑层接口

com/itheima/service/UserService.java

public interface UserService {

    /**
     * 查询所有用户
     */
    public List<User> list();

}

2.2.4 业务逻辑接口实现类

com/itheima/service/impl/UserServiceImpl.java

public class UserServiceImpl implements UserService {
    
    private UserDao userDao = new UserDaoImpl();
    @Override
    public List<User> list() {
        //1. 调用dao层, 获取数据
        List<String> lines = userDao.list();

        //2. 业务逻辑处理: 解析数据, 封装User对象 --> List<User>
        List<User> userList = lines.stream().map(line -> {
            String[] split = line.split(",");
            return new User(
                    Integer.parseInt(split[0]),
                    split[1],
                    split[2],
                    split[3],
                    Integer.parseInt(split[4]),
                    LocalDateTime.parse(split[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        }).toList();
        return userList;
    }
}

2.3 数据访问层（DAO）

2.3.1 功能

数据访问：负责与数据库进行交互，执行增删改查操作。
封装数据库操作：提供统一的数据访问接口，屏蔽底层数据库的细节。

2.3.2 数据层接口

com/itheima/dao/UserDao.java

public interface UserDao {
    /**
     * 查询所有用户
     */
    public List<String> list();

}

2.3.3 数据层接口实现类

com/itheima/dao/impl/UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    @Override
    public List<String> list() {
        //1. 读取user.txt中的数据
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
        ArrayList<String> lines = IoUtil.readUtf8Lines(in, new ArrayList<>());
        return lines;
    }
}

2.4 整体流程

客户端发起请求：用户通过浏览器或其他客户端发送HTTP请求到服务器。
Controller接收请求：Controller接收到请求后，调用Service层的方法。
Service处理业务逻辑：Service层处理业务逻辑，如果需要操作数据库，则调用DAO层的方法。
DAO操作数据库：DAO层执行具体的数据库操作（如查询、插入、更新、删除）。
Service返回结果：Service层处理完业务逻辑后，返回结果给Controller。
Controller响应客户端：Controller将结果转换为HTTP响应，返回给客户端。

在这里插入图片描述

2.5 三层架构拆分的优势

高内聚低耦合：每一层都有明确的职责，降低了各层之间的耦合度。
易于维护和扩展：每一层都可以独立地进行修改和扩展，不影响其他层。
良好的可测试性：每一层都可以单独进行单元测试，提高了测试的效率和准确性。

2.6 部分代码解释

2.6.1 List & ArrayList

在Java中，List是一个接口，定义了列表操作的标准方法，而ArrayList是List接口的一个实现类，基于动态数组，允许存储不同类型的元素，且大小可自动扩展。

2.6.2 面向对象的特性—多态

Java中的多态是一种面向对象编程的特性，它允许一个引用变量指向不同类的对象，并根据实际引用的对象类型来执行对应的方法。多态主要通过继承和方法重写来实现：

继承：子类继承父类，获得父类的属性和方法。
方法重写：子类可以重写父类的方法，提供不同的实现。
向上转型：将子类对象赋值给父类引用，例如：Parent p = new Child();。

3. 分层解耦

3.1 核心概念

3.1.1 耦合

耦合是指软件中各个层或各个模块之间的依赖关联程度。高耦合意味着一个模块对其他模块的依赖性很强，这通常会导致代码难以维护和扩展。低耦合则表示模块之间的依赖关系较弱，这样可以提高系统的灵活性和可维护性。

3.1.2 内聚

内聚是指软件中各个功能模块内部的功能联系。高内聚意味着一个模块内部的功能紧密相关，每个功能都围绕同一个目标或任务进行。低内聚则表示模块内部的功能较为分散，缺乏明确的中心任务。
在这里插入图片描述

3.1.3 控制反转 (IoC)

控制反转（Inversion of Control，简称IoC）是一种设计模式，它将对象的创建控制权从程序自身转移到外部容器。这意味着程序不再直接创建对象，而是由外部容器负责创建和管理这些对象。这种思想称为控制反转。

3.1.4 依赖注入 (DI)

依赖注入（Dependency Injection，简称DI）是实现控制反转的一种常用方法。在依赖注入中，容器为应用程序提供运行时所依赖的资源。具体来说，容器会创建对象并将其所需的依赖项注入到对象中，而不是让对象自己去查找或创建这些依赖项。

3.1.5 Bean对象

Bean对象是指在IoC容器中创建和管理的对象。这些对象通常通过配置文件或注解的方式告诉容器如何创建和管理它们。容器负责实例化这些对象，并将它们所需要的依赖项注入进来。
在这里插入图片描述

3.2 相关注解

在Spring框架中，@Component和@Autowired是两个非常重要的注解，它们分别用于定义Bean和实现依赖注入。下面详细介绍这两个注解的用途、使用方法及其区别。

3.2.1 @Component 注解

@Component 是一个通用注解，用于指示Spring容器自动检测并注册类为Spring管理的Bean。任何被标注了 @Component 的类都会被Spring的组件扫描机制发现，并注册为Spring应用上下文中的一个Bean。

3.2.1.1 @Component 衍生注解

注解	说明	位置
@Component	声明bean的基础注解	不属于以下三类时，用此注解
@Controller	@Component的衍生注解	标注在控制层类上（强制）
@Service	@Component的衍生注解	标注在业务层类上
@Repository	@Component的衍生注解	标注在数据访问层类上（由于与mybatis整合，用的少）

声明Bean的时候，可以通过注解value属性指定Bean的名字，如 Component("userDao")，如果没有指定，默认类名首字母小写

3.2.1.2 @RestController 注解

其中，@RestController 是 Spring Framework 中的一个组合注解，它主要用于简化创建 RESTful Web 服务的过程。具体来说，@RestController 是以下两个注解的组合：

@Controller：这是 Spring MVC 中的一个注解，用于标记一个类作为控制器。被 @Controller 注解的类可以处理 HTTP 请求，并且通常会返回视图名称（例如 JSP 或 Thymeleaf 页面）。
@ResponseBody：这个注解用于标注方法，表示该方法的返回值应该直接写入 HTTP 响应体中，而不是解析为视图名称。这意味着你可以直接返回对象、集合和字符串等，Spring 会自动将它们转换为 JSON 或 XML 格式（取决于请求的 Accept 头部信息）。

3.2.2 @ComponentScan注解

组件扫描注解：这些注解声明的 Bean 需要被 @ComponentScan 注解扫描才能生效。
默认扫描范围：@SpringBootApplication 注解中隐式包含了 @ComponentScan 注解，默认扫描的范围是启动类所在包及其子包。在我们的案例中，默认扫描 com/itheima/ 包及其子包路径下的Bean对象。

3.2.3 @Autowired 注解

@Autowired 注解用于自动装配（依赖注入）。它可以应用于构造器、字段或setter方法上，Spring会尝试找到匹配的Bean来自动装配属性。（Spring 框架提供）

根据图片中的内容，基于@Autowired进行依赖注入的常见方式有如下三种：

3.2.3.1 三种依赖注入方式

3.2.3.1.1 属性注入

代码示例：

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    //......
}

优点：代码简洁、方便快速开发。
点：隐藏了类之间的依赖关系，可能会破坏类的封装性。

3.2.3.1.2 构造函数注入

代码示例：

@RestController
public class UserController {
    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
}

优点：能清晰地看到类的依赖关系，提高了代码的安全性。
点：代码繁琐，如果构造参数过多，可能会导致构造函数臃肿。
注意：如果只有一个构造函数，@Autowired注解可以省略。

3.2.3.1.3 setter注入

代码示例：

@RestController
public class UserController {
    private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

优点：保持了类的封装性，依赖关系更清晰。
点：需要额外编写setter方法，增加了代码量。

3.2.3.2 相同类型的bean三种解决方案

3.2.3.2.1 @Primary

描述：通过在其中一个bean上添加@Primary注解，Spring会优先选择带有@Primary注解的bean进行注入。

代码示例：

@Primary
@Service
public class UserServiceImpl implements UserService {
    // ...
}

3.2.3.2.2 @Qualifier

描述：通过在@Autowired注解上添加@Qualifier注解，并指定具体的bean名称，Spring会根据指定的名称进行注入。

代码示例：

@RestController
public class UserController {
    @Autowired
    @Qualifier("userServiceImpl")
    private UserService userService;
}

3.2.3.2.3 @Resource

描述：通过在字段或方法上使用@Resource注解，并指定具体的bean名称，Spring会根据指定的名称进行注入。（JAVAEE 规范提供）

代码示例：

@RestController
public class UserController {
    @Resource(name = "userServiceImpl")
    private UserService userService;
}

3.3 三层架构解耦

3.3.1 控制层解耦

com/itheima/controller/UserController.java

/**
 * 用户信息Controller
 */
@RestController //@Controller + @ResponseBody -----> 如果返回的是一个对象/集合 --> 转json --> 响应
public class UserController {

    private UserService userService = new UserServiceImpl();
        ...
    }
}

@RestController //@Controller + @ResponseBody -----> 如果返回的是一个对象/集合 --> 转json --> 响应
public class UserController {

    @Autowired
    private UserService userService;
        ...
}

3.3.2 业务逻辑层解耦

com/itheima/service/impl/UserServiceImpl.java

public class UserServiceImpl implements UserService {
    
    private UserDao userDao = new UserDaoImpl();
    @Override
    public List<User> list() {
    	...
    }
}

@Service //将当前类交给spring管理, 声明为spring容器中bean对象
public class UserServiceImpl implements UserService {

    @Autowired //自动装配: 应用程序在运行时, 会自动的从容器中找到该类型的对象, 并赋值给该变量
    private UserDao userDao;

    @Override
    public List<User> list() {
    	...
    }
}

3.3.3 数据访问层解耦

com/itheima/dao/impl/UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    @Override
    public List<String> list() {
        ...
    }
}

@Repository //将当前类交给spring管理, 声明为spring容器中bean对象
public class UserDaoImpl implements UserDao {
    @Override
    public List<String> list() {
    	...
    }
}