基于框架spring boot 2.7.18，mybatius,数据库MySQL，实现一个用户管理系统，系统里面有增删改查接口,分为三层控制层，服务层，数据层，把sql放入mapper文件中
好的，下面是一个基于Spring Boot 2.7.18、MyBatis和MySQL的用户管理系统的实现示例。该系统包含用户管理的增删改查（CRUD）接口，分为控制层（Controller）、服务层（Service）和数据层（Data Layer），并将SQL语句放在Mapper文件中。
项目结构
```
user-management/
├── src/
│ ├── main/
│ │ ├── java/com/example/usermanagement/
│ │ │ ├── controller/
│ │ │ │ └── UserController.java
│ │ │ ├── entity/
│ │ │ │ └── User.java
│ │ │ ├── mapper/
│ │ │ │ └── UserMapper.java
│ │ │ ├── service/
│ │ │ │ ├── UserService.java
│ │ │ │ └── impl/
│ │ │ │ └── UserServiceImpl.java
│ │ │ └── UserManagementApplication.java
│ │ └── resources/
│ │ ├── application.properties
│ │ └── mapper/
│ │ └── UserMapper.xml
│ └── test/
│ └── java/com/example/usermanagement/
│ └── UserManagementApplicationTests.java
├── pom.xml
```
1. 配置 `pom.xml`
确保你的 `pom.xml` 文件包含必要的依赖项：
```xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>user-management</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>user-management</name>
<description>用户管理系统</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.18</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- MyBatis Spring Boot Starter -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
<!-- MySQL Connector -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Lombok (可选，用于简化代码) -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
<scope>provided</scope>
</dependency>
<!-- Spring Boot DevTools (可选，用于开发时自动重启) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<!-- 测试依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Spring Boot Maven Plugin -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.7.18</version>
</plugin>
</plugins>
</build>
</project>
```
2. 配置数据库连接
在 `src/main/resources/application.properties` 中配置数据库连接：
```properties
MySQL 配置
spring.datasource.url=jdbc:mysql://localhost:3306/userdb?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
MyBatis 配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.usermanagement.entity
日志级别
logging.level.root=INFO
logging.level.org.mybatis=DEBUG
```
确保在 MySQL 中创建了 `userdb` 数据库，并创建相应的 `users` 表：
```sql
CREATE DATABASE userdb;
USE userdb;
CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL,
password VARCHAR(50) NOT NULL,
email VARCHAR(100),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```
3. 创建实体类 `User.java`
```java
package com.example.usermanagement.entity;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class User {
private Integer id;
private String username;
private String password;
private String email;
private LocalDateTime createdAt;
}
```
4. 创建 Mapper 接口 `UserMapper.java`
```java
package com.example.usermanagement.mapper;
import com.example.usermanagement.entity.User;
import org.apache.ibatis.annotations.*;
import java.util.List;
public interface UserMapper {
@Select("SELECT * FROM users WHERE id = #{id}")
User findById(Integer id);
@Select("SELECT * FROM users")
List<User> findAll();
@Insert("INSERT INTO users(username, password, email) VALUES(#{username}, #{password}, #{email})")
@Options(useGeneratedKeys = true, keyProperty = "id")
void insert(User user);
@Update("UPDATE users SET username = #{username}, password = #{password}, email = #{email} WHERE id = #{id}")
void update(User user);
@Delete("DELETE FROM users WHERE id = #{id}")
void delete(Integer id);
}
```
5. 创建 Mapper XML（可选）
如果你更喜欢使用 XML 配置 SQL，可以创建 `UserMapper.xml`：
```xml
<?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.usermanagement.mapper.UserMapper">
<resultMap id="UserResultMap" type="User">
<id property="id" column="id" />
<result property="username" column="username" />
<result property="password" column="password" />
<result property="email" column="email" />
<result property="createdAt" column="created_at" />
</resultMap>
<select id="findById" parameterType="int" resultMap="UserResultMap">
SELECT * FROM users WHERE id = #{id}
</select>
<select id="findAll" resultMap="UserResultMap">
SELECT * FROM users
</select>
<insert id="insert" parameterType="User" useGeneratedKeys="true" keyProperty="id">
INSERT INTO users(username, password, email)
VALUES(#{username}, #{password}, #{email})
</insert>
<update id="update" parameterType="User">
UPDATE users
SET username = #{username},
password = #{password},
email = #{email}
WHERE id = #{id}
</update>
<delete id="delete" parameterType="int">
DELETE FROM users WHERE id = #{id}
</delete>
</mapper>
```