Spring Boot集成MyBatis学习大纲：从基础入门到实战应用

一、基础知识

（一）Spring Boot基础

Spring Boot简介
- Spring Boot是基于Spring框架的扩展，旨在简化Spring应用的初始搭建以及开发过程。它通过“约定大于配置”的理念，使得开发者可以快速上手，无需过多配置即可创建一个功能完备的Spring应用。
- 了解Spring Boot的核心优势，如自动配置、独立运行、无需部署WAR文件、内嵌Servlet容器等。
Spring Boot核心概念
- 自动配置：Spring Boot会根据添加的依赖自动配置Spring和相关技术。例如，当添加了spring-boot-starter-web依赖后，Spring Boot会自动配置Tomcat和Spring MVC。
- 启动器（Starter）：Spring Boot提供了一系列的“启动器”，这些启动器是依赖管理的集合，可以帮助开发者快速引入所需的依赖。例如，spring-boot-starter-web包含了构建Web应用所需的所有依赖。
- 应用生命周期：了解Spring Boot应用的启动过程，包括加载配置文件、初始化Spring容器、自动配置组件等。
创建Spring Boot项目
- 使用Spring Initializr：通过Spring官网提供的Spring Initializr工具，快速生成Spring Boot项目。选择项目的基本信息，如项目名称、依赖等，然后下载生成的项目代码。
- 使用IDEA创建项目：借助IDEA的Spring Initializr集成功能，直接在IDEA中创建Spring Boot项目。也可以通过Maven或Gradle手动创建项目，并添加Spring Boot的父依赖。

（二）MyBatis基础

MyBatis简介
- MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plain Old Java Objects，普通老式Java对象）映射成数据库中的记录。
- 了解MyBatis的设计理念，它既提供了SQL的灵活性，又通过映射机制简化了数据操作。
MyBatis核心组件
- SqlSession：是MyBatis的核心对象，用于执行SQL语句、获取映射器和管理事务。
- Mapper接口：是MyBatis的映射接口，定义了与数据库操作相关的方法。这些方法与SQL语句一一对应。
- SQL映射文件：包含SQL语句和Java对象的映射关系。通过<select>、<insert>、<update>、<delete>等标签定义SQL语句，并通过resultMap或resultType指定结果映射。
MyBatis工作原理
- 了解MyBatis的加载过程：加载配置文件（mybatis-config.xml）、初始化环境、构建会话工厂（SqlSessionFactory）、创建会话（SqlSession）、执行SQL语句、映射结果到Java对象。
- 掌握MyBatis的执行流程：通过Mapper接口调用方法，MyBatis会根据方法名和参数找到对应的SQL语句，执行SQL语句并返回结果。
MyBatis基础操作
- CRUD操作：通过Mapper接口和SQL映射文件，实现数据的增删改查操作。例如：
  - 插入数据：在Mapper接口中定义int insertUser(User user);方法，在SQL映射文件中使用<insert>标签定义插入SQL语句。
  - 查询数据：在Mapper接口中定义User selectUserById(int id);方法，在SQL映射文件中使用<select>标签定义查询SQL语句。
  - 更新数据：在Mapper接口中定义int updateUser(User user);方法，在SQL映射文件中使用<update>标签定义更新SQL语句。
  - 删除数据：在Mapper接口中定义int deleteUserById(int id);方法，在SQL映射文件中使用<delete>标签定义删除SQL语句。
- 参数传递：了解MyBatis如何传递参数，包括单个参数、多个参数、JavaBean作为参数等。
- 结果映射：掌握resultType和resultMap的区别和使用场景。resultType用于简单映射，resultMap用于复杂映射，如嵌套查询、嵌套结果等。

二、环境搭建

（一）开发工具安装

JDK安装
- Java Development Kit（JDK）是开发Java应用的基础环境。根据项目需求选择合适的JDK版本（如JDK 8或JDK 11）。安装完成后，配置环境变量，确保可以在命令行中使用java和javac命令。
Maven安装
- Maven是一个项目管理和构建自动化工具，用于依赖管理、项目构建、文档生成等。下载并安装Maven，配置环境变量，确保可以在命令行中使用mvn命令。
MySQL数据库安装
- MySQL是一个开源的关系型数据库管理系统。下载并安装MySQL数据库，配置数据库服务，创建数据库和用户，并授权用户访问数据库。
IDEA开发工具安装
- IntelliJ IDEA是一个功能强大的Java开发IDE，提供了良好的Spring Boot和MyBatis支持。下载并安装IDEA，安装完成后，配置Maven插件和数据库插件，以便更好地进行项目开发。
Navicat数据库管理工具安装
- Navicat是一个数据库管理工具，可以方便地连接和管理MySQL数据库。下载并安装Navicat，连接到MySQL数据库，创建数据库表，管理数据。

（二）Spring Boot项目创建

使用Spring Initializr创建项目
- 访问Spring Initializr官网（https://start.spring.io/），填写项目基本信息，如项目名称、项目描述、依赖等。选择Spring Web、MyBatis Framework、MySQL Driver等依赖，然后点击“Generate”按钮生成项目代码。下载生成的项目代码并解压，导入到IDEA中。
使用IDEA创建项目
- 打开IDEA，选择“File”->“New”->“Project”，在弹出的对话框中选择“Spring Initializr”，点击“Next”。在“Spring Initializr”页面中填写项目基本信息，如项目名称、项目描述、依赖等。选择Spring Web、MyBatis Framework、MySQL Driver等依赖，点击“Next”按钮，完成项目创建。

手动创建项目

创建一个Maven项目，在pom.xml文件中添加Spring Boot的父依赖和MyBatis、MySQL等依赖。例如：

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.7.1</version>
</parent>

<dependencies>
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.2.0</version>
  </dependency>
  <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <scope>runtime</scope>
  </dependency>
</dependencies>

创建Application类，作为Spring Boot应用的入口。例如：

@SpringBootApplication
public class MyApplication {
  public static void main(String[] args) {
      SpringApplication.run(MyApplication.class, args);
  }
}

三、项目配置

（一）依赖配置

添加Spring Boot依赖
- 在pom.xml文件中，通过<parent>标签添加Spring Boot的父依赖，确保项目继承了Spring Boot的核心功能和依赖管理。例如：
```
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.7.1</version>
</parent>
```

添加MyBatis依赖

添加mybatis-spring-boot-starter依赖，用于集成MyBatis和Spring Boot。例如：

<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.2.0</version>
</dependency>

添加MySQL依赖

添加mysql-connector-java依赖，用于连接MySQL数据库。例如：

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>

（二）数据源配置

配置数据源信息

在application.properties或application.yml文件中，配置数据源的相关信息，如数据库URL、用户名、密码、驱动类等。例如：

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase?useSSL=false&serverTimezone=UTC&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

如果使用application.yml文件，配置格式如下：

spring:
datasource:
  url: jdbc:mysql://localhost:3306/mydatabase?useSSL=false&serverTimezone=UTC&characterEncoding=utf-8
  username: root
  password: 123456
  driver-class-name: com.mysql.cj.jdbc.Driver

（三）MyBatis配置

配置MyBatis相关属性
- 在application.properties或application.yml文件中，配置MyBatis的相关属性，如SQL映射文件位置、实体类包路径、日志实现等。例如：
```
# MyBatis配置
mybatis.mapper-locations=classpath:mappers/*.xml
mybatis.type-aliases-package=com.example.demo.entity
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
```
- 如果使用application.yml文件，配置格式如下：
```
mybatis:
mapper-locations: classpath:mappers/*.xml
type-aliases-package: com.example.demo.entity
configuration:
  log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
```
- mapper-locations：指定SQL映射文件的位置，可以使用通配符*。
- type-aliases-package：指定实体类所在的包路径，MyBatis会自动扫描该包下的类，并为其生成别名。
- log-impl：指定MyBatis的日志实现，这里使用标准输出日志，方便调试。

配置MyBatis配置文件（可选）

如果需要更复杂的MyBatis配置，可以创建mybatis-config.xml文件，放在resources目录下。例如：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <settings>
      <setting name="mapUnderscoreToCamelCase" value="true"/>
  </settings>
</configuration>

在application.properties或application.yml文件中，指定mybatis-config.xml文件的位置：
```
mybatis.config-location=classpath:mybatis-config.xml
```

四、核心组件开发

（一）实体类编写

根据数据库表结构创建实体类

假设数据库中有一个user表，表结构如下：

CREATE TABLE user (
  id INT PRIMARY KEY AUTO_INCREMENT,
  username VARCHAR(50) NOT NULL,
  password VARCHAR(50) NOT NULL,
  email VARCHAR(50)
);

根据表结构，创建对应的实体类User：

package com.example.demo.entity;

public class User {
  private Integer id;
  private String username;
  private String password;
  private String email;

  // Getters and Setters
  public Integer getId() {
      return id;
  }

  public void setId(Integer id) {
      this.id = id;
  }

  public String getUsername() {
      return username;
  }

  public void setUsername(String username) {
      this.username = username;
  }

  public String getPassword() {
      return password;
  }

  public void setPassword(String password) {
      this.password = password;
  }

  public String getEmail() {
      return email;
  }

  public void setEmail(String email) {
      this.email = email;
  }
}

实体类的属性名与数据库表字段名一一对应。如果数据库表字段名使用下划线命名（如user_name），而实体类属性名使用驼峰命名（如userName），可以通过MyBatis的mapUnderscoreToCamelCase设置自动转换。

（二）Mapper接口开发

定义Mapper接口

创建一个接口UserMapper，定义与user表相关的操作方法。例如：

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper {
  // 查询用户
  User selectUserById(Integer id);

  // 插入用户
  int insertUser(User user);

  // 更新用户
  int updateUser(User user);

  // 删除用户
  int deleteUserById(Integer id);
}

在接口上使用@Mapper注解，标记该接口为MyBatis的Mapper接口。
接口中的方法名与SQL映射文件中的SQL语句一一对应。例如，selectUserById方法对应于查询用户信息的SQL语句。

（三）Mapper XML映射文件编写

创建SQL映射文件

在resources/mappers目录下，创建UserMapper.xml文件，编写SQL语句，并将其与Mapper接口中的方法进行映射。例如：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
  <!-- 查询用户 -->
  <select id="selectUserById" parameterType="int" resultType="com.example.demo.entity.User">
      SELECT * FROM user WHERE id = #{id}
  </select>

  <!-- 插入用户 -->
  <insert id="insertUser" parameterType="com.example.demo.entity.User">
      INSERT INTO user (username, password, email) VALUES (#{username}, #{password}, #{email})
  </insert>

  <!-- 更新用户 -->
  <update id="updateUser" parameterType="com.example.demo.entity.User">
      UPDATE user SET username = #{username}, password = #{password}, email = #{email} WHERE id = #{id}
  </update>

  <!-- 删除用户 -->
  <delete id="deleteUserById" parameterType="int">
      DELETE FROM user WHERE id = #{id}
  </delete>
</mapper>

namespace：指定Mapper接口的全限定名。
id：与Mapper接口中的方法名一致。
parameterType：指定方法的参数类型。
resultType：指定查询结果的映射类型，这里映射到User实体类。
在SQL语句中，使用#{}占位符绑定参数。例如，#{id}表示方法参数中的id属性。

（四）Service层开发

创建Service接口

创建一个接口UserService，定义业务逻辑方法。例如：

package com.example.demo.service;

import com.example.demo.entity.User;

public interface UserService {
  User getUserById(Integer id);

  int addUser(User user);

  int updateUser(User user);

  int deleteUserById(Integer id);
}

Service接口用于封装业务逻辑，调用Mapper接口完成数据操作。

（五）Controller层开发

创建Controller类

创建一个类UserController，作为Spring MVC的控制器，接收客户端请求，调用Service层方法，并返回响应结果。例如：

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
  @Autowired
  private UserService userService;

  // 查询用户
  @GetMapping("/{id}")
  public User getUserById(@PathVariable Integer id) {
      return userService.getUserById(id);
  }

  // 插入用户
  @PostMapping
  public int addUser(@RequestBody User user) {
      return userService.addUser(user);
  }

  // 更新用户
  @PutMapping
  public int updateUser(@RequestBody User user) {
      return userService.updateUser(user);
  }

  // 删除用户
  @DeleteMapping("/{id}")
  public int deleteUserById(@PathVariable Integer id) {
      return userService.deleteUserById(id);
  }
}

使用@RestController注解标记该类为控制器，@RequestMapping("/users")指定请求的根路径。
在方法上使用@GetMapping、@PostMapping、@PutMapping、@DeleteMapping注解，分别对应HTTP的GET、POST、PUT、DELETE请求。
使用@PathVariable注解绑定路径参数，@RequestBody注解绑定请求体中的JSON数据到Java对象。

五、功能实现与测试

（一）CRUD功能实现

插入数据

在UserMapper.xml文件中，定义插入SQL语句：

<insert id="insertUser" parameterType="com.example.demo.entity.User">
  INSERT INTO user (username, password, email) VALUES (#{username}, #{password}, #{email})
</insert>

在UserMapper接口中，定义插入方法：
```
int insertUser(User user);
```
在UserService接口中，定义插入方法：
```
int addUser(User user);
```

在UserServiceImpl类中，实现插入方法：

@Override
public int addUser(User user) {
  return userMapper.insertUser(user);
}

在UserController类中，定义插入方法：

@PostMapping
public int addUser(@RequestBody User user) {
  return userService.addUser(user);
}

测试插入功能：通过Postman或其他工具发送POST请求到/users，请求体中包含JSON数据：
```
{
  "username": "testuser",
  "password": "123456",
  "email": "test@example.com"
}
```
如果插入成功，返回插入的行数（通常是1）。

（二）分页功能实现

使用MyBatis分页插件PageHelper

在pom.xml文件中，添加PageHelper依赖：

<dependency>
  <groupId>com.github.pagehelper</groupId>
  <artifactId>pagehelper-spring-boot-starter</artifactId>
  <version>1.4.5</version>
</dependency>

在application.properties或application.yml文件中，配置PageHelper：

pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.params=count=countSql

在Service层中，使用PageHelper实现分页查询。例如：

public Page<User> getUsersByPage(int pageNum, int pageSize) {
  PageHelper.startPage(pageNum, pageSize);
  List<User> users = userMapper.selectAllUsers();
  return new Page<>(users);
}

在Mapper接口中，定义查询所有用户的方法：
```
List<User> selectAllUsers();
```

在Mapper XML文件中，定义查询所有用户的SQL语句：

<select id="selectAllUsers" resultType="com.example.demo.entity.User">
  SELECT * FROM user
</select>

在Controller层中，定义分页查询方法：

@GetMapping
public Page<User> getUsersByPage(@RequestParam int pageNum, @RequestParam int pageSize) {
  return userService.getUsersByPage(pageNum, pageSize);
}

测试分页功能：通过浏览器或Postman发送GET请求到/users?pageNum=1&pageSize=10，返回分页结果。

（三）事务管理

配置事务管理器
- 在Spring Boot中，默认已经配置了事务管理器DataSourceTransactionManager。可以通过@EnableTransactionManagement注解启用事务管理，通常在配置类上添加该注解。
- 在application.properties或application.yml文件中，配置事务相关属性：
```
spring.datasource.transaction-type=JDBC
spring.datasource.sql-script-encoding=UTF-8
```
- 在Service层方法上，使用@Transactional注解声明事务。例如：
```
@Transactional
public int addUser(User user) {
  int result = userMapper.insertUser(user);
  if (result <= 0) {
      throw new RuntimeException("插入用户失败");
  }
  return result;
}
```
- 如果方法执行过程中抛出异常，事务会回滚。

（四）项目测试

单元测试

使用JUnit编写单元测试，测试Service层和Mapper层的方法。例如：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
  @Autowired
  private UserService userService;

  @Test
  public void testAddUser() {
      User user = new User();
      user.setUsername("testuser");
      user.setPassword("123456");
      user.setEmail("test@example.com");
      int result = userService.addUser(user);
      assertEquals(1, result);
  }
}

使用@SpringBootTest注解启动Spring Boot应用上下文，@Autowired注入需要测试的组件。

集成测试
- 使用Postman或其他工具发送HTTP请求，测试Controller层的功能。例如：
- 测试查询用户功能：发送GET请求到/users/{id}，验证返回的用户信息是否正确。
- 测试插入用户功能：发送POST请求到/users，请求体中包含用户信息，验证是否插入成功。
- 测试分页功能：发送GET请求到/users?pageNum=1&pageSize=10，验证返回的分页结果是否正确。

六、高级特性

（一）动态SQL

使用<if>标签

在Mapper XML文件中，使用<if>标签实现条件判断。例如：

<select id="selectUsersByCondition" resultType="com.example.demo.entity.User">
  SELECT * FROM user
  <where>
      <if test="username != null and username != ''">
          AND username = #{username}
      </if>
      <if test="email != null and email != ''">
          AND email = #{email}
      </if>
  </where>
</select>

在Mapper接口中，定义方法：

List<User> selectUsersByCondition(@Param("username") String username, @Param("email") String email);

在Service层中，调用该方法：

public List<User> getUsersByCondition(String username, String email) {
  return userMapper.selectUsersByCondition(username, email);
}

在Controller层中，定义方法：

@GetMapping("/search")
public List<User> getUsersByCondition(@RequestParam(required = false) String username,
                                    @RequestParam(required = false) String email) {
  return userService.getUsersByCondition(username, email);
}

测试动态SQL功能：发送GET请求到/users/search?username=testuser&email=test@example.com，验证返回的用户列表是否符合条件。

（二）缓存机制

一级缓存
- MyBatis的一级缓存是SqlSession级别的缓存，默认开启。在同一个SqlSession中，多次查询相同的数据，MyBatis会从缓存中直接返回结果，而不会再次查询数据库。
- 一级缓存的作用域是SqlSession，当SqlSession关闭或提交事务时，一级缓存会清空。
二级缓存
- MyBatis的二级缓存是Mapper级别的缓存，需要手动配置。在application.properties或application.yml文件中，配置二级缓存：
```
mybatis.configuration.cache-enabled=true
```
- 在Mapper XML文件中，配置二级缓存：
```
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
```
- eviction：指定缓存的回收策略，可选值有FIFO（先进先出）、LRU（最近最少使用）、SOFT（软引用）、WEAK（弱引用）。
- flushInterval：缓存刷新间隔时间，单位为毫秒。这里设置为60000毫秒（1分钟）。
- size：缓存的最大对象数量。
- readOnly：是否只读。如果设置为true，则缓存的对象是只读的，不能被修改。如果设置为false，则缓存的对象可以被修改，但需要手动同步到数据库。

（三）插件开发

自定义MyBatis插件

创建一个类实现Interceptor接口，自定义插件逻辑。例如：

@Intercepts({@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class MybatisInterceptor implements Interceptor {
  @Override
  public Object intercept(Invocation invocation) throws Throwable {
      // 在执行SQL之前，可以在这里添加逻辑
      System.out.println("Before executing SQL");

      // 执行SQL
      Object result = invocation.proceed();

      // 在执行SQL之后，可以在这里添加逻辑
      System.out.println("After executing SQL");

      return result;
  }

  @Override
  public Object plugin(Object target) {
      return Plugin.wrap(target, this);
  }

  @Override
  public void setProperties(Properties properties) {
      // 可以在这里设置插件的属性
  }
}

在application.properties或application.yml文件中，注册自定义插件：

mybatis.configuration.interceptors=com.example.demo.interceptor.MybatisInterceptor

当MyBatis执行SQL时，会调用自定义插件的intercept方法，可以在该方法中添加自定义逻辑，如日志记录、SQL性能监控等。

七、项目优化与部署

（一）性能优化

优化SQL语句
- 分析SQL语句的执行计划，确保SQL语句的性能。使用EXPLAIN命令查看SQL语句的执行计划，优化索引、查询条件等。
优化数据库索引
- 根据查询条件和表结构，合理创建索引。例如，对于经常查询的字段（如username、email），可以创建索引以提高查询效率。
使用缓存
- 合理使用MyBatis的一级缓存和二级缓存，减少数据库查询次数。对于不经常变化的数据（如字典表），可以使用二级缓存。
异步处理
- 对于耗时的操作（如发送邮件、日志记录等），可以使用Spring的异步任务（@Async）或消息队列（如RabbitMQ）进行异步处理，提高应用的响应速度。

（二）项目部署

打包项目
- 使用Maven命令mvn clean package打包项目，生成可执行的jar文件。
部署到服务器
- 将生成的jar文件上传到服务器，使用命令java -jar myproject.jar启动应用。
配置服务器环境
- 确保服务器上安装了JDK和MySQL数据库，配置好数据库连接信息。
- 可以使用Nginx作为反向代理，配置HTTPS证书，提高应用的安全性和性能。

八、实战项目

（一）项目实战

项目需求分析
- 以一个简单的用户管理系统为例，分析项目需求。用户管理系统需要实现用户信息的增删改查、分页查询、用户登录等功能。

数据库设计

设计用户表user，包含字段id、username、password、email、created_at、updated_at等。

创建数据库和表：

CREATE DATABASE user_management;

USE user_management;

CREATE TABLE user (
  id INT PRIMARY KEY AUTO_INCREMENT,
  username VARCHAR(50) NOT NULL,
  password VARCHAR(50) NOT NULL,
  email VARCHAR(50),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

项目开发
- 按照前面的步骤，创建Spring Boot项目，集成MyBatis，开发用户管理系统的各个功能模块。
- 实体类：创建User实体类，映射用户表。
- Mapper接口和SQL映射文件：定义UserMapper接口和UserMapper.xml文件，实现用户信息的增删改查操作。
- Service层：创建UserService接口和UserServiceImpl类，封装业务逻辑。
- Controller层：创建UserController类，接收客户端请求，调用Service层方法，并返回响应结果。
- 分页功能：使用PageHelper实现分页查询。
- 事务管理：在Service层方法上使用@Transactional注解，管理事务。
- 缓存机制：合理使用MyBatis的二级缓存，提高查询效率。
- 安全功能：实现用户登录功能，使用Spring Security进行身份认证和授权。
项目测试
- 编写单元测试和集成测试，测试项目中的各个功能模块。
- 使用Postman或其他工具发送HTTP请求，测试Controller层的功能。
项目部署
- 将项目打包为jar文件，部署到服务器上。
- 配置服务器环境，确保应用正常运行。

（二）扩展功能

用户角色管理
- 添加角色表role和用户角色关系表user_role，实现用户角色管理功能。
- 修改User实体类，添加角色信息。
- 修改UserMapper接口和SQL映射文件，实现用户角色的查询和更新。
- 修改UserService和UserController，添加用户角色管理的接口和方法。
权限管理
- 添加权限表permission和角色权限关系表role_permission，实现权限管理功能。
- 修改Role实体类，添加权限信息。
- 修改RoleMapper接口和SQL映射文件，实现角色权限的查询和更新。
- 修改RoleService和RoleController，添加权限管理的接口和方法。
- 使用Spring Security实现基于角色的权限控制。
日志管理
- 使用Spring Boot的application.properties或application.yml文件，配置日志级别和日志文件路径。
- 使用Logback或Log4j2作为日志框架，记录应用的运行日志。
- 实现日志查询功能，方便开发者查看日志信息。

posted @ 2025-03-25 17:04 软件职业规划阅读(196) 评论(0) 收藏举报

刷新页面返回顶部