Spring Boot 学习笔记：项目搭建、分层架构与核心技术集成

基本项目结构

springBoot项目创建

• 直接创建（简单）
• 通过maven创建（常用）

直接创建

用过idea

版本问题

Springboot2.x --> JDK8

Springboot3.x --> JDK17

要使用jdk8 需要更改server url镜像

http://start.aliyun.com

创建成功

通过maven创建

创建一个maven项目

在pom.xml中进行继承springBoot

<!--  继承springBoot-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.13</version>
  </parent>

导入spring依赖

<!--    springboot wed模块-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

构建springboot启动类

controller控制类

1. 类定义与注解

@Controller  // 标识这是一个控制器类，用于处理HTTP请求
@RequestMapping("user")  // 类级别的请求路径映射，所有方法的路径都会以"/user"为前缀
@ResponseBody  // 作用于类上，表示该类所有方法的返回值会直接作为响应体返回给前端（而非跳转页面）
public class UserController { ... }

2. 核心注解说明

• @Controller：
  Spring 的核心注解之一，告诉 Spring 这是一个控制器组件，负责接收和处理客户端请求。
• @RequestMapping(“user”)：
  定义请求路径的映射规则。类上添加后，该类中所有方法的访问路径都需要加上/user前缀。
  例如：下面的text()方法访问路径为 /user/text。
• @ResponseBody：
  表示方法的返回值会直接转换为 JSON / 字符串等格式，作为 HTTP 响应体返回给前端（常用于接口开发）。
  如果不加此注解，Spring 会默认将返回值解析为页面名称（用于视图跳转）。

3. 方法定义

@RequestMapping("text")  // 方法级别的请求路径映射，完整访问路径为 "/user/text"
public String text() {
    System.out.println("看看我执行了没有");  // 控制台输出日志，用于调试
    return "success";  // 返回字符串"success"给前端
}

4. 功能说明

当前端发送 HTTP 请求到路径 /user/text 时：

1. Spring 会根据@RequestMapping注解找到UserController中的text()方法。
2. 执行方法内的逻辑（打印日志）。
3. 将返回值"success"作为响应体返回给前端（如浏览器会显示 “success”）。

package com.cykj.controller;
import com.cykj.vo.UserVO;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @className: UserController
 * @author: ahatc
 * @date: 2025/8/21 01:47
 * @version: 1.0
 * @description: TODO
 */
//可以进行请求响应
@Controller
//请求映射
@RequestMapping("user")
//把方法的返回值返回给前端,不加默认返回页面
@ResponseBody
public class UserController {

    //1.简单的请求
    //http://127.0.0.1:8080/user/text
    @RequestMapping("text")
    public String text(){
        System.out.println("看看我执行了没有");
        return "success";
    }

    //2.请求携带参数
    //http://127.0.0.1:8080/user/login?username=zahngsan&password=123456
    @RequestMapping("login")
    public void login(String username,String password){
        System.out.println("我收到的账号："+username);
        System.out.println("我收到的密码："+password);
    }

    //3.参数很多==>封装成一个对象
    //http://127.0.0.1:8080/user/text03?id=2&username=rfw&password=213
    //参数名跟对象中属性名一样就会自动映射
    @RequestMapping("text03")
    public void text03(UserVO user){
        System.out.println(user);
    }

    //也可以请求页面 在resources下放static静态资源（页面）
    
}

mapper数据库操作

导入mysql mybatis依赖

类似mybatis操作注意.xml文件有固定的约束头

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//[mybatis](mybatis.md).org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--namespace与接口绑定-->
<mapper namespace="org.example.mapper.UserMapper">  //包名+类名==>全限定名
  
</mapper>

Spring Boot 会通过 MyBatisAutoConfiguration 类自动完成以下工作：

1. 自动读取配置文件（application.properties 或 application.yml）中的 MyBatis 相关配置
2. 自动创建 SqlSessionFactory 和 SqlSession
3. 自动扫描 Mapper 接口并创建实现类（代理对象）
4. 将 Mapper 代理对象注入到 Spring 容器中

因此，在 Spring Boot 中使用 MyBatis 只需以下几步：

1. 添加依赖（Maven）

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.3.0</version> <!-- 版本号可根据实际情况调整 -->
</dependency>
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

2. 配置数据库连接（application.yml）

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/your_database?useSSL=false&serverTimezone=UTC
    username: root
    password: your_password
    

//mybatis日志
mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl     # 实体类包路径（可选，用于简化xml中的type配置）

3. 创建 Mapper 接口

package com.cykj.mapper;

import com.cykj.pojo.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper  // 标记为MyBatis的Mapper接口，Spring会自动扫描并创建代理对象
public interface UserMapper {
    User findById(int id);
}

4. 创建 Service 层调用 Mapper

package com.cykj.service;

import com.cykj.mapper.UserMapper;
import com.cykj.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    
    // 直接注入Mapper接口，Spring已自动创建代理对象
    @Autowired
    private UserMapper userMapper;
    
    public User getUserById(int id) {
        // 直接调用Mapper方法，无需手动创建SqlSession等
        return userMapper.findById(id);
    }
}

关键简化点：

• 无需手动创建 SqlSessionFactory 和 SqlSession
• 无需手动获取 Mapper 接口实例，直接通过 @Autowired 注入
• 配置集中在 application.yml，无需单独的 MyBatis 配置文件（如 mybatis-config.xml）
• 通过 @Mapper 注解或在启动类添加 @MapperScan("com.cykj.mapper") 批量扫描 Mapper 接口

这样就实现了 MyBatis 与 Spring Boot 的无缝集成，大大简化了开发流程。

分层架构

在典型的 Spring Boot 分层架构中，通常分为 控制层（Controller）、业务层（Service）、数据访问层（Mapper/Repository），有时还会包含 实体层（Entity/POJO） 和 工具层（Util） 等辅助层。各层职责明确，通过分层实现 “高内聚、低耦合”，便于维护和扩展。

这就是典型的 MVC（Model-View-Controller）+ Service + DAO 架构。

1. 实体层（Entity/POJO/Model）

• 核心作用：封装数据，映射数据库表结构或业务数据模型。

• 具体说明

  ：

  • 通常对应数据库中的表，类的属性与表的字段一一对应（如 User 类对应 user 表，id、username 等属性对应表字段）。

  • 包含属性的 getter/setter 方法，有时会添加构造方法或重写 toString() 方便调试。

  • 示例

    public class User {
        private Integer id;
        private String username;
        private String password;
        // getter、setter、构造方法...
    }
    

2. 数据访问层（Mapper/Repository/DAO）

• 核心作用：直接与数据库交互，负责数据的增删改查（CRUD）操作。

• 具体说明

  ：

  • 在 MyBatis 中通常称为 Mapper，通过接口 + XML 或注解定义 SQL 操作。

  • 不包含业务逻辑，仅专注于数据读写，方法名通常对应操作（如 findById、insertUser）。

  • 示例（MyBatis Mapper 接口）：

    @Mapper
    public interface UserMapper {
        User findById(Integer id); // 查询用户
        int insert(User user); // 新增用户
    }
    

3. 业务层（Service）

• 核心作用：处理核心业务逻辑，协调数据访问层与控制层，是业务规则的实现中心。

• 具体说明

  • 编写业务逻辑（如注册、下单、积分计算等）

  • 事务控制（使用 @Transactional）

  • 调用多个 Mapper 或外部服务

  • 拆分复杂业务流程，提升可复用性

    // 接口
    public interface UserService {
        User getUserById(Integer id);
    }
    
    // 实现类
    @Service
    public class UserServiceImpl implements UserService {
        @Autowired
        private UserMapper userMapper;   //通过@Autowired自动注入 不需要新建对象
        
        @Override
        public User getUserById(Integer id) {
            if (id == null || id <= 0) {
                throw new IllegalArgumentException("ID无效"); // 业务校验
            }
            return userMapper.findById(id); // 调用数据访问层
        }
    }
    

4. 控制层（Controller）

• 核心作用：接收前端请求，调用业务层处理，返回响应结果（如 JSON、页面）。

• 具体说明

  • 接收 HTTP 请求（@GetMapping/@PostMapping）

  • 处理请求参数（@RequestParam/@RequestBody）

  • 调用 Service 进行业务处理

  • 返回响应结果（ResponseEntity/JSON）

    @RestController
    @RequestMapping("/users")
    public class UserController {
        @Autowired
        private UserService userService;
        
        @GetMapping("/{id}")
        public ResponseEntity<User> getUser(@PathVariable Integer id) {
            User user = userService.getUserById(id);
            return ResponseEntity.ok(user); // 返回用户数据
        }
    }
    

5. 其他辅助层

• 工具层（Util）：存放通用工具类（如日期处理、加密、校验工具等），供各层调用。
• DTO 层（Data Transfer Object）：用于前后端数据传输的对象，可能与实体类不同（如简化字段、组合多表数据）。
• 异常处理层（Exception Handler）：通过 @ControllerAdvice 统一处理全局异常，返回友好提示。

各层调用关系

前端请求 → Controller（接收请求）→ Service（处理业务）→ Mapper（操作数据）→ 数据库
响应流程相反：数据库 → Mapper → Service → Controller → 前端

Controller 管接口，Service 管逻辑，Mapper 管数据库，Model 管数据结构(VO)。

src/
 └── main/
     ├── java/com/example/demo/
     │   ├── controller/     // 接收请求
     │   ├── service/        // 编写业务逻辑
     │   ├── mapper/         // 与数据库交互
     │   ├── model/          // 数据对象（Entity）
     │   ├── config/         // 配置类
     │   └── DemoApplication.java
     └── resources/
         ├── mapper/         // MyBatis XML 文件
         └── application.yml // 配置文件

类命名规范（VO与DO）

跟数据库映射的实体对象 后缀带DO

接收前端传输的数据 后缀带VO

1. DO（Data Object 数据对象）

   • 用途：与数据库表直接映射，字段和表结构一一对应（如数据库有user表，就有UserDO）
   • 关联层：后端与数据库交互（如 MyBatis 用 DO 查 / 存数据）
   • 特点：仅含数据库表字段，无多余逻辑，是数据库数据在代码中的 “镜像”

2. VO（Value Object 值对象）

   • 用途：专门接收前端传输的数据（如表单提交、接口入参），或向前端返回指定数据
   • 关联层：前后端交互（前端传参→后端用 VO 接收；后端返回数据→用 VO 封装给前端）
   • 特点：字段按需定义（可只包含前端需要的部分数据，无需和数据库表一致），可加参数校验（如非空、长度限制）

3. 核心区别

   维度	DO	VO
   对应对象	数据库表	前后端交互数据
   核心作用	数据库数据载体	前后端数据传输载体
   字段来源	数据库表结构	前后端业务需求

注解

注解（Annotation）是 Java 语言的一种特殊标记，它可以在代码中添加元数据（描述数据的数据），用于告诉程序（编译器、框架等）如何处理这段代码。

注解本身不会直接影响代码的执行逻辑，但框架（如 Spring Boot）可以通过反射机制读取注解信息，从而实现特定功能（如自动注入、请求映射等）。

简单说，注解就像代码的 “标签”，框架通过识别这些标签来完成相应的自动处理，减少手动配置的工作量

1. MyBatis 相关注解

• @Mapper（UserMapper.java）
  • 用途：标记该接口为 MyBatis 的映射器接口，MyBatis 会自动扫描并创建该接口的实现类，用于数据库操作。
• @Param（UserMapper.java）
  • 用途：在 Mapper 接口方法的参数前使用，用于给参数命名。在 XML 映射文件中可以通过该名称引用参数（如 #{id}）。

2. Spring 相关注解

• @RequestBody（Controller 方法参数前）
  • 用途：标记该参数需要从 HTTP 请求体（Request Body）中获取数据，SpringMVC 会自动将请求体中的 JSON/XML 格式数据解析并绑定到该参数对象上，实现前端复杂数据（如对象、嵌套结构）向后端 Java 对象的自动转换，简化前后端数据交互。
• @Service（UserService.java 和 UserServiceImpl.java）
  • 用途：标记类为 Spring 管理的服务层组件，用于业务逻辑处理。Spring 会自动扫描并将其纳入 IoC 容器管理。
• @Autowired（UserServiceImpl.java 和 UserController.java）
  • 用途：自动注入依赖对象。Spring 会从 IoC 容器中查找匹配类型的 bean 并注入到字段中（如注入 UserMapper 到 UserServiceImpl）。
• @Controller（UserController.java）
  • 用途：标记类为 Spring MVC 的控制器，用于处理 HTTP 请求。
• @RequestMapping（UserController.java）
  • 用途：映射 HTTP 请求路径到控制器类或方法。
    • 在类上使用：指定该控制器的基础路径（如 @RequestMapping("user") 表示所有方法的路径前缀为 /user）。
    • 在方法上使用：指定具体方法处理的请求路径（如 @RequestMapping("text") 对应路径 /user/text）。
• @ResponseBody（UserController.java）
  • 用途：作用于控制器方法，将方法的返回值直接作为 HTTP 响应体返回给前端（而非跳转页面），通常用于返回 JSON 或字符串数据。
• @SpringBootApplication（App.java）
  • 用途：Spring Boot 应用的核心注解，组合了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan，用于启动 Spring Boot 应用并自动配置组件扫描、自动配置等功能。

3. Lombok 相关注解

• @Data

  • 用途：Lombok 提供的注解，自动为类生成 getter、setter、toString()、equals()、hashCode() 等方法，简化代码编写。

返回前端

文件夹dto

ResponseDTO

DTO（Data Transfer Object，数据传输对象）是一种专门用于在不同层（通常是服务层与前端、或不同服务之间）传输数据的对象

创建dto类存储需要返回的内容一般包括

private Integer statusCode;

private String message;

private Object data;

以ResponseDOT类新建对象 返回前端

前后端交互