最新初学者入门JavaWeb——后端

Maven 使用 pom.xml 文件来定义项目的依赖关系。开发者只需在 pom.xml 中声明所需的依赖库，Maven 会自动从中央仓库（如 Maven Central Repository）下载这些依赖及其传递性依赖，确保项目中使用的是正确版本的库。
依赖管理功能极大地简化了项目依赖的配置和管理，避免了版本冲突和重复依赖的问题。
Maven 的 pom.xml 文件不仅用于依赖管理和构建配置，还可以包含项目的基本信息（如项目名称、版本号、开发者信息等）。这些信息可以用于生成项目的文档、报告等。

点击进行下一步，这里可以选择基础依赖项。

在软件开发中，依赖项（Dependencies）是指一个项目或模块在运行或构建过程中需要的外部资源，通常是其他库或框架。这些依赖项提供了项目所需的特定功能、工具或服务，使得开发者可以复用已有的代码，而无需从头开始编写所有功能。

依赖项的作用

代码复用：依赖项允许开发者使用已有的、经过测试的代码库，从而减少重复劳动，提高开发效率。
功能扩展：通过引入外部库，项目可以快速获得额外的功能，例如数据库操作、网络通信、日志记录等。
维护和更新：依赖项通常由专业的团队维护，开发者可以通过更新依赖项来获取最新的功能和安全修复。

点击创建。到此，我们就成功创建了一个项目。

记得点击加载maven项目。由于是第一次创建，所以项目加载时间会比较长。

如果大家想重新回到配置依赖项的界面，就可以通过pom.xml文件点击编辑启动器。这样，就能重回依赖项界面。下文还有其他添加依赖项的方法。

所以，需要配置的基本依赖项，有以下几项供大家进行参考。

Lombok:

Lombok 是一个 Java 库，通过注解简化 Java 的样板代码，例如自动生成 getter、setter、toString 等方法。

Spring Configuration Processor:Spring 的配置处理器，用于在编译时生成元数据文件，帮助 IDE 提供自动补全和验证功能。

Spring Web:

Spring Web 模块提供了构建 Web 应用的功能，包括 RESTful API 和 MVC 控制器。

JDBC API:

Java 数据库连接（JDBC）API 提供了与数据库交互的标准方法。

Spring Data JPA:

Spring Data JPA 提供了对 Java 持久化 API（JPA）的支持，简化了数据库操作。

MyBatis Framework:

MyBatis 是一个持久层框架，支持定制化 SQL 和动态 SQL，适合复杂的数据库操作。

MySQL Driver:

MySQL JDBC 驱动程序，用于连接 MySQL 数据库。

CycloneDX SBOM support:

MySQL JDBC 驱动程序，用于连接 MySQL 数据库。

配置基础项目结构

三层架构（“高内聚、低耦合”）

三层架构（Three-Tier Architecture）是一种常见的软件设计模式，将应用程序分为三个主要的逻辑层：表示层（Presentation Layer）、业务逻辑层（Business Logic Layer）和数据访问层（Data Access Layer）。这种架构模式有助于提高代码的可维护性、可扩展性和可重用性。

1. 表示层（Presentation Layer）

表示层是用户与应用程序交互的界面，负责接收用户输入并展示处理结果。它通常包括：

前端界面：如 HTML、CSS、JavaScript 等。
后端控制器：如 Spring MVC 中的 @Controller 或 @RestController。

职责：

接收用户请求。
调用业务逻辑层处理请求。
将处理结果返回给用户。

2. 业务逻辑层（Business Logic Layer）

业务逻辑层是应用程序的核心，负责处理业务规则和逻辑。它通常包括：

服务类：如 Spring 中的 @Service。
业务逻辑处理：如数据验证、业务规则计算等。

职责：

接收表示层的请求。
调用数据访问层获取或操作数据。
处理业务逻辑并返回结果。

3. 数据访问层（Data Access Layer）

数据访问层负责与数据库交互，执行数据的增、删、改、查操作。它通常包括：

Mapper 接口：如 MyBatis 中的 @Mapper。
数据访问对象（DAO）：如 JPA 中的 JpaRepository。

职责：

提供数据访问接口。
封装数据库操作细节。
返回数据给业务逻辑层。

三层架构的优势

解耦：各层之间相对独立，便于维护和扩展。
可重用性：业务逻辑和数据访问逻辑可以被多个表示层复用。
可测试性：各层可以独立进行单元测试，提高代码质量。
可扩展性：便于添加新的功能或修改现有功能，而无需影响其他层。

三层架构的交互流程

用户请求：用户通过表示层发起请求。
表示层调用业务逻辑层：表示层将请求转发给业务逻辑层。
业务逻辑层调用数据访问层：业务逻辑层根据业务规则调用数据访问层获取或操作数据。
数据访问层返回数据：数据访问层执行数据库操作后返回数据。
业务逻辑层处理数据：业务逻辑层处理返回的数据并返回结果。
表示层返回结果：表示层将处理结果返回给用户。

以下是我建立的项目的结构：

src/
├── main/
│   ├── java/
│   │   └── com/example/mybatisplus/
│   │       ├── MyBatisPlusApplication.java      # Spring Boot主启动类
│   │       ├── controller/                      # 控制器层(Controller)
│   │       ├── service/                         # 服务层(Service)
│   │       │   └── impl/                        # 服务层的具体实现
│   │       ├── mapper/                          # MyBatis Mapper接口(DAO层)
│   │       └── pojo/                            # 实体类(POJO/DTO/VO等)
│   └── resources/
│       ├── static/                              # 静态资源(JS/CSS/图片等)
│       ├── templates/                           # 模板文件(如Thymeleaf)
│       └── application.properties               # 配置文件
└── test/                                       # 测试代码

这个项目结构体现了三层架构的设计模式，通过将代码分为表示层、业务逻辑层和数据访问层，实现了代码的高内聚、低耦合。同时，项目还包括了静态资源、模板文件、配置文件和测试代码等其他组成部分，这些部分虽然不属于三层架构的核心，但也是现代 Web 应用开发中不可或缺的部分。

实现代码解释

控制器层（Controller）

存放控制器层代码，通常使用 @Controller 或 @RestController 注解。控制器层负责处理 HTTP 请求，并调用服务层的方法。

package com.exercise.mybatisplus.controller;

import com.exercise.mybatisplus.pojo.Result;
import com.exercise.mybatisplus.pojo.User;
import com.exercise.mybatisplus.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.*;

/**
 * 用户相关接口
 * 这个类定义了与用户相关的所有 RESTful API 接口。
 */
@Configuration
@CrossOrigin(origins = "http://localhost:5173", allowCredentials = "true")
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    /**
     * 创建新用户
     * @param user 用户对象，包含用户的基本信息
     * @return 返回一个 Result 对象，表示操作的结果
     */
    @PostMapping("/add")
    public Result addUser(@RequestBody User user){
        System.out.println("创建新用户");
        int code = userService.insertUser(user); // 调用服务层的 insertUser 方法
        if (code == 0) { // 如果返回码为 0，表示用户已存在
            return Result.success("该用户已存在");
        }
        return Result.success(user); // 返回创建成功的用户对象
    }
}

关键点解释

`@Configuration`

作用：标记该类为一个配置类，Spring 会将其加载到 Spring 容器中。

关键点：虽然 @RestController 已经足够让 Spring Boot 将该类识别为一个控制器，但 @Configuration 可以进一步明确这是一个配置类，有助于代码的可读性。

`@CrossOrigin`

作用：允许跨域请求。这里配置了允许来自 http://localhost:5173 的请求，并允许携带凭证（如 cookies）。

关键点：在开发阶段，前端和后端通常运行在不同的端口上，需要配置跨域以允许前端调用后端接口。allowCredentials = "true" 表示允许携带凭证，这对于需要登录状态的接口非常重要。

`@RestController`

作用：标记该类为一个 RESTful 控制器，返回的数据通常是 JSON 或 XML 格式，而不是 HTML 页面。

关键点：与 @Controller 不同，@RestController 默认不会返回视图，而是直接返回数据，适合构建 RESTful API。

`@RequestMapping("/user")`

作用：定义了该控制器的根路径。所有该控制器下的接口路径都会以 /user 开头。

关键点：通过路径分组可以更好地组织接口，使接口路径更加清晰。

其他 HTTP 方法映射注解

@GetMapping - 处理 HTTP GET 请求

@PutMapping - 处理 HTTP PUT 请求

@DeleteMapping - 处理 HTTP DELETE 请求

@PatchMapping - 处理 HTTP PATCH 请求

@RequestMapping - 通用请求映射，可指定 method 属性为 RequestMethod.POST

MyBatis-Plus Mapper接口(DAO层)

Mapper 接口（DAO 层）是与数据库交互的核心组件。它定义了与数据库表相关的操作方法，这些方法通常对应于数据库的增、删、改、查等操作。MyBatis-Plus 提供了强大的基础功能，使得开发人员可以非常方便地进行数据库操作，同时也可以根据需要扩展自定义的方法。

package com.exercise.mybatisplus.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.exercise.mybatisplus.pojo.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

关键点解释

`@Mapper`

作用：标记该接口为一个 MyBatis 的 Mapper 接口。

关键点：

@Mapper 注解是 MyBatis 提供的，用于标记接口为 Mapper 接口。

在 Spring Boot 项目中，@Mapper 注解会自动将接口注册为一个 Bean，Spring 容器会管理这个 Bean。

通常，你可以在每个 Mapper 接口上使用 @Mapper 注解，或者在启动类上使用 @MapperScan 注解来批量扫描指定包路径下的所有 Mapper 接口。

`BaseMapper<User>`

作用：BaseMapper 是 MyBatis-Plus 提供的一个接口，包含了一系列基本的 CRUD 操作方法。

关键点：

BaseMapper 提供了以下基本方法：

int insert(T entity)：插入一条记录。

int deleteById(Serializable id)：根据 ID 删除记录。

int updateById(T entity)：根据 ID 更新记录。

T selectById(Serializable id)：根据 ID 查询记录。

List<T> selectList(Wrapper<T> queryWrapper)：查询多条记录。

int selectCount(Wrapper<T> queryWrapper)：查询记录数。

等等。

通过继承 BaseMapper，UserMapper 接口自动获得了这些基本方法，无需手动编写 SQL 语句。

自定义方法

作用：除了 BaseMapper 提供的基本方法外，你还可以在 Mapper 接口中定义自定义方法，以满足特定的业务需求。

示例：

User selectByName(String name)根据用户名查询用户。

自定义方法的实现可以通过 MyBatis 的 XML 配置文件或注解来完成。

实体类(POJO/DTO/VO等)

定义实体类，用于映射数据库中的表。使用了 MyBatis-Plus 提供的注解来指定表名、字段名以及主键生成策略。

package com.exercise.mybatisplus.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

@TableName("user") // 指定数据库表名
public class User {
    @TableId(type= IdType.AUTO)// 关键注解：指定数据库自增
    private Integer userId;
    @TableField("username")   // 指定数据库中的字段名
    private String userName;
    private Integer age;

    public User() {
    }

    public User(Integer userId, String userName, Integer age) {
        this.userId = userId;
        this.userName = userName;
        this.age = age;
    }
     //Get和Set方法
}

关键点解释

`@TableName("user")`

作用：指定实体类对应的数据库表名。

关键点：如果不使用 @TableName 注解，MyBatis-Plus 默认会将类名转换为表名（例如，User 类对应 user 表）。使用 @TableName 注解可以明确指定表名，避免歧义。

`@TableId(type = IdType.AUTO)`

作用：指定主键字段，并设置主键生成策略。

关键点：

@TableId 注解用于指定主键字段。

type = IdType.AUTO 表示主键由数据库自动生成（通常是自增主键）。这是 MySQL 中常见的主键生成策略。

其他常见的主键生成策略包括：

IdType.NONE：表示主键由数据库生成（默认策略）。

IdType.INPUT：表示主键由用户手动输入。

IdType.ID_WORKER：表示主键由 MyBatis-Plus 提供的分布式 ID 生成器生成（类似 Twitter 的 Snowflake 算法）。

`@TableField("username")`

作用：指定实体类字段对应的数据库字段名。

关键点：

如果实体类字段名与数据库字段名不一致，可以使用 @TableField 注解来指定数据库中的字段名。

在这个例子中，实体类字段名是 userName，而数据库字段名是 username。

package com.exercise.mybatisplus.pojo;

public class Result {
    private Integer code;  // 1=成功, 0=失败
    private String msg;    // 响应信息
    private Object data;   // 返回数据

    public Result() {
    }

    public Result(Integer code, String msg, Object data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
    // 成功（无数据）
    public static Result success() {
        return new Result(1, "success", null);
    }
    // 成功（带数据）
    public static Result success(Object data) {
        return new Result(1, "success", data);
    }
    // 失败
    public static Result error(String msg) {
        return new Result(0, msg, null);
    }
    //Get和Set方法
}

这段代码定义了一个通用的响应类 Result，用于封装 API 的响应结果。这种设计模式在构建 RESTful API 时非常常见，因为它可以提供统一的响应格式，方便前端处理和调试。

我们需要提一下Lombok

Lombok 是一个非常流行的 Java 库，它通过注解的方式简化了 Java 的代码编写，尤其是减少了大量的模板代码，让代码更加简洁易读。如@Data，这是 Lombok 最常用的注解之一，它会自动生成以下内容：getter 和 setter 方法，toString() 方法，equals() 和 hashCode() 方法。博主没有用到Lombok，不是不想用，而是配置依赖有问题，用不了。

服务层(Service)

服务层（Service Layer）是应用程序中负责处理业务逻辑的部分，它介于控制器层和数据访问层之间。通过定义服务层接口和实现类 Impl，可以清晰地分离接口定义和具体实现，同时利用 MyBatis-Plus 提供的通用方法，减少重复代码，提高开发效率。

由于使用的是mybatis-plus。所以需要把对应的依赖项放到pom.xml文件里面 .

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.10.1</version>
</dependency>

package com.exercise.mybatisplus.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.exercise.mybatisplus.pojo.User;

public interface UserService extends IService<User> {
    int insertUser(User user);
}

这段代码定义了一个服务层接口，它继承了 MyBatis-Plus 提供的接口，并扩展了一个自定义方法。

关键点解释

`UserService` 接口

作用：定义了服务层需要实现的方法，用于操作 User 实体类对应的数据库表。

关键点：接口中的方法通常由服务层实现类（如 UserServiceImpl）具体实现。

`IService<User>`

作用：IService 是 MyBatis-Plus 提供的一个通用服务接口，它定义了一系列基本的 CRUD 操作方法。

关键点：

IService 泛型参数 User 表示操作的实体类。

继承 IService 可以让 UserService 接口自动获得 MyBatis-Plus 提供的基本 CRUD 操作方法。

这些方法包括但不限于 save、saveBatch、removeById、removeByIds、updateById、getById 等。

`insertUser(User user)` 方法

作用：定义了一个自定义方法，用于插入一个新的用户记录。

关键点：

这个方法的具体实现将在服务层实现类中完成。

方法返回值为 int，表示影响的行数。通常，插入成功时返回值为 1。

服务层的作用

服务层的主要作用是处理业务逻辑，它通常包括以下内容：

业务规则：实现业务逻辑，如验证、计算、转换等。
事务管理：管理事务，确保数据的一致性。
调用数据访问层：调用数据访问层（DAO 层）的方法，执行数据库操作。
与控制器层交互：接收控制器层的请求，返回处理结果给控制器层。

服务层的具体实现

这段代码定义服务层实现类，它继承了 MyBatis-Plus 提供的 ServiceImpl 类，并实现了接口。

package com.exercise.mybatisplus.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.exercise.mybatisplus.mapper.UserMapper;
import com.exercise.mybatisplus.pojo.User;
import com.exercise.mybatisplus.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public int insertUser(User user) {
        return userMapper.insert(user);
    }
}

小小思考

当服务层实现类继承了 ServiceImpl，MyBatis-Plus 会自动为你提供一个 baseMapper，这是一个 BaseMapper 的实例。BaseMapper 提供了一系列基本的 CRUD 操作方法。这些方法可以直接用于执行数据库操作，而无需手动注入 UserMapper。这段代码还有必要使用吗？会不会显得冗余？

@Autowired
    private UserMapper userMapper;

移除 `@Autowired` 的好处

减少冗余代码：如果你已经继承了 ServiceImpl，那么 baseMapper 已经可用，无需再手动注入 UserMapper。
利用通用实现：ServiceImpl 提供的 baseMapper 已经实现了基本的 CRUD 操作，直接使用可以减少重复代码。
简化依赖注入：移除手动注入后，代码更加简洁，依赖管理更加清晰。

不移除`@Autowired的原因`

当需要实现一些 baseMapper 无法提供的自定义操作时，可以直接注入并使用 UserMapper。

可以在以下情况下使用直接注入的 UserMapper：

自定义 SQL 操作：需要执行复杂的、baseMapper 不支持的 SQL 查询
特殊条件查询：需要编写 XML 或注解方式的复杂条件查询
存储过程调用：需要调用数据库存储过程
多表关联操作：需要进行复杂的多表关联查询

最佳实践建议

可以在 Service 中直接注入 UserMapper 来实现 baseMapper 无法提供的功能
推荐优先使用 baseMapper 访问自定义方法，保持一致性
建议将复杂查询封装在 Mapper 层，Service 层调用
避免同时使用 baseMapper 和注入的 userMapper 完成相同功能

当您确实需要超出 IService 和 BaseMapper 提供的功能时，直接使用 UserMapper 是完全合理的做法，这也是 MyBatis-Plus 设计的灵活性所在。

例子

@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 自定义方法
    User selectByUsername(@Param("username") String username);
    
    // 复杂查询
    List<User> selectByComplexCondition(@Param("query") UserQuery query);
}

@Service
@RequiredArgsConstructor
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    
    // 方式1：使用基类的 baseMapper (推荐)
    @Override
    public User getByUsername(String username) {
        return baseMapper.selectByUsername(username);
    }
    
    // 方式2：使用构造器注入的 mapper (Lombok @RequiredArgsConstructor)
    private final UserMapper userMapper;
    
    @Override
    public List<User> getByComplexCondition(UserQuery query) {
        return userMapper.selectByComplexCondition(query);
    }
}

关键点解释

`@Service`

作用：标记该类为一个服务层组件，Spring 容器会自动管理这个 Bean。

关键点：@Service 是 Spring 的注解，用于标识服务层类，便于 Spring 容器进行依赖注入。

`ServiceImpl<UserMapper, User>`

作用：ServiceImpl 是 MyBatis-Plus 提供的一个通用服务实现类，它提供了基本的 CRUD 操作方法。

关键点：

ServiceImpl 泛型的第一个参数是 Mapper 接口，第二个参数是实体类。

通过继承 ServiceImpl，UserServiceImpl 类自动获得了基本的 CRUD 操作方法，无需手动实现这些方法。

ServiceImpl 内部已经实现了 BaseMapper 的所有方法，可以直接使用。

`UserMapper` 和 `User`

UserMapper：定义了与数据库表相关的操作方法，继承自 BaseMapper。

User：实体类，对应数据库中的 user 表。

`@Autowired`

作用：自动注入 UserMapper，使得可以在服务层中直接使用 Mapper 接口的方法。

关键点：@Autowired 是 Spring 的注解，用于自动注入依赖的 Bean。

`insertUser(User user)` 方法

作用：插入一个新的用户记录。

关键点：

调用 userMapper.insert(user) 方法，这是 BaseMapper 提供的方法，用于插入一条记录。

返回值是 int 类型，表示影响的行数。如果插入成功，返回值通常为 1。

通过这种设计，UserServiceImpl 类可以快速实现对用户数据的基本操作，同时也可以根据需要扩展自定义的方法。

数据库Mysql相关

Navicat

一款功能强大的数据库管理和开发工具，支持多种数据库系统，包括 MySQL、MariaDB、PostgreSQL、SQLite、Oracle 和 SQL Server 等。它提供了直观的图形用户界面（GUI），帮助数据库管理员和开发人员高效地管理数据库。

连接数据库

创建连接：
- 在 Navicat 的主界面中，点击左上角的“连接”按钮。
- 选择你使用的数据库类型（如 MySQL、PostgreSQL 等）。
- 填写连接信息，包括主机名、端口、用户名和密码等。
- 点击“测试连接”按钮，确保连接信息正确无误。
- 点击“确定”保存连接。
连接到数据库：
- 在左侧的连接列表中，选择你刚刚创建的连接，双击连接到数据库。
- 连接成功后，你将看到数据库的结构和数据。

管理数据库对象

创建表：
- 在连接的数据库上右键点击，选择“新建表”。
- 在表设计器中，输入表名和字段信息，包括字段名、数据类型、是否为主键等。
- 点击“保存”按钮，完成表的创建。
查看和编辑数据：
- 在左侧的导航栏中，展开数据库，找到你创建的表。
- 双击表名，进入数据查看器。
- 在数据查看器中，你可以查看、添加、修改和删除数据。
执行 SQL 查询：
- 在连接的数据库上右键点击，选择“新建查询”。
- 在查询编辑器中，输入 SQL 语句，如 SELECT * FROM your_table;。
- 点击“执行”按钮，查看查询结果。

建立好一张表后，我们需要在IDEA中连接数据库。

IDEA连接数据库

打开 Data Source 工具窗口

直接在右侧工具栏找到 Database 图标并点击。

添加数据源

在 Database 工具窗口中，点击左上角的 + 按钮，选择 Data Source，然后选择你想要连接的数据库类型。这里我使用的是MySQL。
以 MySQL 数据库为例：
- Driver：选择 MySQL。
- URL：输入数据库的连接 URL，格式通常是 jdbc:mysql://<host>:<port>/<database_name>。例如，如果你的数据库服务器地址是 localhost，端口是 3306，数据库名称是 test_db，那么 URL 就是 jdbc:mysql://localhost:3306/test_db。
- User：输入数据库的用户名。
- Password：输入数据库的密码。
- 其他可选配置：你可以根据需要配置其他参数，如连接池设置等。

测试连接

填写完上述信息后，点击 Test Connection 按钮来测试连接是否成功。如果连接成功，会弹出一个提示框显示“Connection successful”，否则会显示错误信息，你需要根据错误信息检查配置是否正确。

查看和操作数据库

连接成功后，可以在 Database 工具窗口中看到数据库的结构，包括表、视图等。可以通过右键点击表来执行 SQL 查询、查看表结构、插入数据等操作。

配置文件内容

application.properties 文件，用于配置数据源、MyBatis-Plus 和服务器端口等信息。

spring.application.name=_______自己的
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/______自己的
spring.datasource.username=root
spring.datasource.password=______自己的
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
mybatis.configuration.map-underscore-to-camel-case=true
server.port=______自己的，端口号可修改

到这里，我们有突破了一大难题。接下来，让我们步入后端的最后一个模块——接口测试。