<think>我们被要求整合
Spring Boot + MyBatis + Swagger。这是一个常见的Java Web开发技术栈组合。
我们将创建一个简单的
Spring Boot项目，集成
MyBatis（用于数据访问）和Swagger（用于API文档）。
步骤如下：
1. 创建
Spring Boot项目
2. 添加相关依赖（
Spring Boot,
MyBatis, Swagger,
数据库驱动等）
3. 配置数据源和
MyBatis
4. 创建实体类、
Mapper接口和
Mapper XML文件
5. 创建Service和Controller
6. 配置Swagger
7. 运行并测试
下面我们逐步实现：
步骤1：创建
Spring Boot项目
可以使用
Spring Initializr（https://start.
spring.io/）创建一个基础的
Spring Boot项目，选择以下依赖：
-
Spring Web
-
MyBatis Framework
- MySQL Driver (这里以MySQL为例，也可以选择其他
数据库)
步骤2：添加Swagger依赖
在pom.xml中添加Swagger相关依赖（这里使用Swagger2）：
```xml
<dependency>
<groupId>io.
springfox</groupId>
<artifactId>
springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.
springfox</groupId>
<artifactId>
springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
```
步骤3：配置数据源和
MyBatis
在application.properties（或application.yml）中配置数据源和
MyBatis：
```properties
# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#
MyBatis配置
# 指定
Mapper.xml文件位置
mybatis.
mapper-locations=classpath:
mapper/*.xml
# 指定实体类所在的包
mybatis.type-aliases-package=com.example.demo.entity
```
步骤4：创建实体类、
Mapper接口和
Mapper XML文件
假设我们有一个User实体类：
实体类：User.java
```java
package com.example.demo.entity;
public class User {
private Long id;
private String name;
private Integer age;
// 省略getter和setter
}
```
Mapper接口：User
Mapper.java
```java
package com.example.demo.
mapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.
Mapper;
import java.util.List;
@
Mapper
public interface User
Mapper {
List<User> findAll();
}
```
Mapper XML文件：在resources/
mapper目录下创建User
Mapper.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.demo.
mapper.User
Mapper">
<select id="findAll" resultType="User">
select * from user
</select>
</
mapper>
```
步骤5：创建Service和Controller
Service接口：UserService.java
```java
package com.example.demo.service;
import com.example.demo.entity.User;
import java.util.List;
public interface UserService {
List<User> findAll();
}
```
Service实现：UserServiceImpl.java
```java
package com.example.demo.service.impl;
import com.example.demo.entity.User;
import com.example.demo.
mapper.User
Mapper;
import com.example.demo.service.UserService;
import org.
springframework.beans.factory.annotation.Autowired;
import org.
springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private User
Mapper user
Mapper;
@Override
public List<User> findAll() {
return user
Mapper.findAll();
}
}
```
Controller：UserController.java
```java
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.Get
Mapping;
import org.
springframework.web.bind.annotation.Request
Mapping;
import org.
springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
@Request
Mapping("/user")
public class UserController {
@Autowired
private UserService userService;
@Get
Mapping("/list")
public List<User> list() {
return userService.findAll();
}
}
```
步骤6：配置Swagger
创建Swagger配置类：SwaggerConfig.java
```java
package com.example.demo.config;
import org.
springframework.context.annotation.Bean;
import org.
springframework.context.annotation.Configuration;
import
springfox.documentation.builders.ApiInfoBuilder;
import
springfox.documentation.builders.PathSelectors;
import
springfox.documentation.builders.RequestHandlerSelectors;
import
springfox.documentation.service.ApiInfo;
import
springfox.documentation.spi.DocumentationType;
import
springfox.documentation.
spring.web.plugins.Docket;
import
springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.example.demo.controller")) // 指定controller存放的目录
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("
Spring Boot整合Swagger")
.description("
Spring Boot整合Swagger，详细信息......")
.version("1.0.0")
.build();
}
}
```
步骤7：运行并测试
启动
Spring Boot应用，访问Swagger UI：http://localhost:8080/swagger-ui.html
注意：确保
数据库中有user表，并且有数据。
以上就是一个简单的
Spring Boot + MyBatis + Swagger的整合示例。
但是，请注意，在实际开发中，我们可能还需要考虑事务管理、异常处理、日志、分页等。这里只是一个最基础的整合。
相关问题：
1. 如何配置
MyBatis的驼峰命名转换？
2. 如何在
Spring Boot中配置多数据源？
3. 如何对Swagger进行安全配置（比如添加登录认证）？
4. 如何整合
MyBatis-Plus来简化
MyBatis的开发？
</think>
以下是一个完整的
Spring Boot + MyBatis + Swagger整合方案，包含详细代码和解释：
### 解决方案
我们将创建一个简单的用户管理系统，包含以下模块：
1.
Spring Boot基础框架
2.
MyBatis操作MySQL
数据库
3. Swagger生成API文档
4. RESTful接口示例
---
### 1. 项目结构
```
src
├── main
│ ├── java
│ │ └── com
│ │ └── example
│ │ └── demo
│ │ ├── config
│ │ │ └── SwaggerConfig.java
│ │ ├── controller
│ │ │ └── UserController.java
│ │ ├── entity
│ │ │ └── User.java
│ │ ├──
mapper
│ │ │ └── User
Mapper.java
│ │ ├── service
│ │ │ ├── UserService.java
│ │ │ └── impl
│ │ │ └── UserServiceImpl.java
│ │ └── DemoApplication.java
│ └── resources
│ ├──
mapper
│ │ └── User
Mapper.xml
│ ├── application.yml
│ └── schema.sql
```
---
### 2. 核心代码实现
#### 依赖 (`pom.xml`)
```xml
<dependencies>
<!--
Spring Boot Starter -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-web</artifactId>
</dependency>
<!--
MyBatis + MySQL -->
<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>
<!-- Swagger -->
<dependency>
<groupId>io.
springfox</groupId>
<artifactId>
springfox-swagger2</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>io.
springfox</groupId>
<artifactId>
springfox-swagger-ui</artifactId>
<version>3.0.0</version>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
```
#### 配置文件 (`application.yml`)
```yaml
server:
port: 8080
spring:
datasource:
url: jdbc:mysql://localhost:3306/demo_db?useSSL=false&serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
mapper-locations: classpath:
mapper/*.xml #
MyBatis映射文件位置
configuration:
map-underscore-to-camel-case: true # 自动驼峰命名转换
# 初始化
数据库脚本
spring.sql.init.mode: always
```
####
数据库初始化 (`schema.sql`)
```sql
CREATE TABLE IF NOT EXISTS users (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(50) NOT
NULL,
email VARCHAR(50) NOT
NULL UNIQUE,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
INSERT INTO users (name, email) VALUES
('张三', 'zhangsan@example.com'),
('李四', 'lisi@example.com');
```
#### 实体类 (`User.java`)
```java
package com.example.demo.entity;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class User {
private Integer id;
private String name;
private String email;
private LocalDateTime createdAt;
}
```
####
Mapper接口 (`User
Mapper.java`)
```java
package com.example.demo.
mapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.*;
import java.util.List;
@
Mapper
public interface User
Mapper {
@Select("SELECT * FROM users")
List<User> findAll();
@Insert("INSERT INTO users(name, email) VALUES(#{name}, #{email})")
@Options(useGeneratedKeys = true, keyProperty = "id")
int insert(User user);
@Delete("DELETE FROM users WHERE id = #{id}")
int deleteById(Integer id);
}
```
#### Service层 (`UserService.java` 和 `UserServiceImpl.java`)
```java
// UserService.java
package com.example.demo.service;
import com.example.demo.entity.User;
import java.util.List;
public interface UserService {
List<User> getAllUsers();
void createUser(User user);
void deleteUser(Integer id);
}
// UserServiceImpl.java
package com.example.demo.service.impl;
import com.example.demo.entity.User;
import com.example.demo.
mapper.User
Mapper;
import com.example.demo.service.UserService;
import org.
springframework.beans.factory.annotation.Autowired;
import org.
springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private User
Mapper user
Mapper;
@Override
public List<User> getAllUsers() {
return user
Mapper.findAll();
}
@Override
public void createUser(User user) {
user
Mapper.insert(user);
}
@Override
public void deleteUser(Integer id) {
user
Mapper.deleteById(id);
}
}
```
#### Controller (`UserController.java`)
```java
package com.example.demo.controller;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.
springframework.beans.factory.annotation.Autowired;
import org.
springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@Request
Mapping("/api/users")
@Api(tags = "用户管理接口")
public class UserController {
@Autowired
private UserService userService;
@Get
Mapping
@ApiOperation("获取所有用户")
public List<User> getAllUsers() {
return userService.getAllUsers();
}
@Post
Mapping
@ApiOperation("创建新用户")
public void createUser(@RequestBody User user) {
userService.createUser(user);
}
@Delete
Mapping("/{id}")
@ApiOperation("删除用户")
public void deleteUser(@PathVariable Integer id) {
userService.deleteUser(id);
}
}
```
#### Swagger配置 (`SwaggerConfig.java`)
```java
package com.example.demo.config;
import org.
springframework.context.annotation.Bean;
import org.
springframework.context.annotation.Configuration;
import
springfox.documentation.builders.ApiInfoBuilder;
import
springfox.documentation.builders.PathSelectors;
import
springfox.documentation.builders.RequestHandlerSelectors;
import
springfox.documentation.service.ApiInfo;
import
springfox.documentation.spi.DocumentationType;
import
springfox.documentation.
spring.web.plugins.Docket;
@Configuration
public class SwaggerConfig {
@Bean
public Docket api() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.example.demo.controller"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("用户管理系统API文档")
.description("
Spring Boot整合
MyBatis和Swagger示例")
.version("1.0.0")
.build();
}
}
```
#### 主启动类 (`DemoApplication.java`)
```java
package com.example.demo;
import org.
mybatis.
spring.annotation.
MapperScan;
import org.
springframework.
boot.
SpringApplication;
import org.
springframework.
boot.autoconfigure.
SpringBootApplication;
@
SpringBootApplication
@
MapperScan("com.example.demo.
mapper") // 扫描
Mapper接口
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
```
---
### 3. 功能验证
1. 启动应用：运行 `DemoApplication`
2. 访问Swagger UI：`http://localhost:8080/swagger-ui/`
3. 测试接口：
- GET `/api/users` 获取用户列表
- POST `/api/users` 创建用户
- DELETE `/api/users/{id}` 删除用户
---
### 4. 关键点解释
1. **
MyBatis集成**：
- `@
MapperScan` 自动扫描
Mapper接口
- `
mapper-locations` 配置XML映射文件路径
- 驼峰命名自动转换简化
字段映射
2. **Swagger配置**：
- `@Api`标注控制器分类
- `@ApiOperation`标注接口功能
- 访问路径 `/swagger-ui/`
3. **RESTful设计**：
- 使用标准HTTP方法 (GET/POST/DELETE)
- 资源化URL设计 (`/api/users`)
---
###
本文解决了一个在SpringBoot结合MyBatis项目中遇到的问题：如何确保查询返回的Map包含值为null的字段。通过加载XML配置文件并设置callSettersOnNulls参数为true来实现。
扫一扫
644
到【灌水乐园】发言
